@imenam/mcp-dependabot-tracker 1.0.32 → 1.0.33
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 +24 -2
- package/dist/src/cli/prompt.d.ts +4 -0
- package/dist/src/cli/prompt.js +28 -0
- package/dist/src/cli/setup.d.ts +55 -0
- package/dist/src/cli/setup.js +484 -0
- package/dist/src/cli/users.js +1 -28
- package/dist/src/core/auth.d.ts +2 -0
- package/dist/src/core/auth.js +4 -0
- package/dist/src/core/commands.d.ts +2 -0
- package/dist/src/core/commands.js +1 -1
- package/dist/src/core/repair.d.ts +14 -0
- package/dist/src/core/repair.js +10 -2
- package/dist/src/core/setup-files.d.ts +48 -0
- package/dist/src/core/setup-files.js +147 -0
- package/dist/src/index.d.ts +1 -0
- package/dist/src/index.js +12 -0
- package/dist/src/server/serve.d.ts +2 -0
- package/dist/src/server/serve.js +1 -1
- package/package.json +1 -1
package/README.md
CHANGED
|
@@ -23,6 +23,28 @@ L'agent fait ce que fait l'utilisateur pour les corrections : il liste les dép
|
|
|
23
23
|
|
|
24
24
|
## Installation
|
|
25
25
|
|
|
26
|
+
### Installation sur un serveur Linux : `setup`
|
|
27
|
+
|
|
28
|
+
Sur une machine Linux avec systemd (Debian, Ubuntu), une seule commande, en root, installe tout le serveur :
|
|
29
|
+
|
|
30
|
+
```bash
|
|
31
|
+
sudo mcp-dependabot-tracker setup
|
|
32
|
+
```
|
|
33
|
+
|
|
34
|
+
Elle pose ses questions, en proposant les valeurs du `.env` existant : adresse publique (`https://…`), port d'écoute sur `127.0.0.1` (4700), compte système du service (`dependabot-tracker`), répertoire des données (`<dossier du compte>/data`), nginx et certificat, premier compte de l'interface (mot de passe saisi sans écho). Elle récapitule, demande confirmation, puis :
|
|
35
|
+
|
|
36
|
+
1. installe les paquets manquants : `git`, `podman`, `uidmap`, `passt`, `slirp4netns`, `catatonit`, `bubblewrap`, `socat`, plus `nginx`, `certbot` et `python3-certbot-nginx` s'ils sont demandés ;
|
|
37
|
+
2. crée le compte système du service, lui attribue une plage de sous-identifiants libre (la suite de toutes celles de `/etc/subuid` et `/etc/subgid`) et active son lingering (`/run/user/<uid>`) ;
|
|
38
|
+
3. écrit le `.env` de la racine du paquet (`DATA_DIR`, `APP_URL`, `APP_PORT`, `TRUSTED_PROXIES`, et `VAULT_KEY` et `AUTH_SECRET`, générés au premier passage puis conservés), lisible par root et le groupe du service seulement ; les autres lignes du fichier sont gardées ;
|
|
39
|
+
4. crée le premier compte de l'interface ;
|
|
40
|
+
5. prépare Podman rootless sous le compte du service (`podman system migrate`) et vérifie qu'il est bien rootless ;
|
|
41
|
+
6. écrit l'unité `/etc/systemd/system/dependabot-tracker.service`, l'active et (re)démarre le service, puis attend que le serveur réponde ;
|
|
42
|
+
7. avec nginx, écrit et active le site `/etc/nginx/sites-available/dependabot-tracker` (proxy vers `127.0.0.1:<port>`), recharge nginx, puis obtient le certificat avec certbot (`--redirect`). Un site nginx déjà activé qui sert la même adresse est gardé tel quel.
|
|
43
|
+
|
|
44
|
+
L'unité garde le durcissement compatible avec Podman rootless et le bac à sable de Claude Code : `ProtectSystem=strict`, `ProtectHome=read-only`, `PrivateTmp`, l'écriture limitée au dossier du compte, aux données et à `/run/user/<uid>`, mais ni `NoNewPrivileges` (`newuidmap` et `newgidmap` sont setuid), ni `RestrictSUIDSGID` (la copie d'une image aux identifiants décalés de `--userns=keep-id` remet les bits setuid et setgid de ses fichiers), ni `RestrictNamespaces`, `PrivateUsers` ou `SystemCallFilter` (bubblewrap).
|
|
45
|
+
|
|
46
|
+
Relancée, la commande reprend la configuration en place : clés, compte de service, plage de sous-identifiants et comptes existants sont gardés, l'unité est réécrite. Sans terminal, ou avec `--non-interactive`, rien n'est demandé : chaque réponse vient d'une option (`--app-url`, `--port`, `--service-user`, `--data-dir`, `--nginx=oui|non`, `--certbot=oui|non`, `--admin-email`, `--admin-name`), sinon du `.env` ou du défaut, et le mot de passe de `SETUP_ADMIN_PASSWORD`. `setup --help` les liste. Il reste ensuite à saisir dans l'interface le token GitHub du tracker, puis le token Claude.
|
|
47
|
+
|
|
26
48
|
### Le serveur
|
|
27
49
|
|
|
28
50
|
```bash
|
|
@@ -41,7 +63,7 @@ sudo loginctl enable-linger "$(whoami)"
|
|
|
41
63
|
podman info --format '{{.Host.Security.Rootless}}'
|
|
42
64
|
```
|
|
43
65
|
|
|
44
|
-
La deuxième commande doit afficher une plage pour le compte dans `/etc/subuid` et dans `/etc/subgid` ; sinon, ajoutez-en une (`sudo usermod --add-subuids 100000-165535 --add-subgids 100000-165535 "$(whoami)"`), puis lancez `podman system migrate`. La dernière doit afficher `true`. Un service systemd lancé sous ce compte déclare aussi le dossier d'exécution de l'utilisateur, que Podman rootless attend : `Environment=XDG_RUNTIME_DIR=/run/user/<uid du compte
|
|
66
|
+
La deuxième commande doit afficher une plage pour le compte dans `/etc/subuid` et dans `/etc/subgid` ; sinon, ajoutez-en une (`sudo usermod --add-subuids 100000-165535 --add-subgids 100000-165535 "$(whoami)"`), puis lancez `podman system migrate`. La dernière doit afficher `true`. Un service systemd lancé sous ce compte déclare aussi le dossier d'exécution de l'utilisateur, que Podman rootless attend : `Environment=XDG_RUNTIME_DIR=/run/user/<uid du compte>`, le laisse en écriture (`ReadWritePaths=/run/user/<uid du compte>` avec `ProtectSystem=strict`), et ne pose ni `NoNewPrivileges` ni `RestrictSUIDSGID` (voir l'unité écrite par `setup`, ci-dessus).
|
|
45
67
|
|
|
46
68
|
Le serveur exige une clé de coffre, `VAULT_KEY`, qui chiffre les clés privées SSH des serveurs de déploiement et les tokens de l'organizer et de Claude. Générez-la une fois et déclarez-la comme variable secrète du service :
|
|
47
69
|
|
|
@@ -245,7 +267,7 @@ Quand les corrections automatiques laissent des vulnérabilités dans une correc
|
|
|
245
267
|
|
|
246
268
|
Une tâche introuvable, sans le tag ou non assignée au propriétaire fait échouer la session, comme une erreur de Claude, un dépassement des limites, le token Claude non réglé, ou un bac à sable impossible : le clone revient au commit des corrections automatiques, l'erreur s'affiche sous l'étape, et la correction pousse quand même les corrections automatiques, avec un avertissement en tête de la pull request. L'annulation de l'opération arrête Claude Code.
|
|
247
269
|
|
|
248
|
-
**Ce que Claude peut faire** — outils intégrés `Read`, `Grep`, `Glob`, `Edit` et `Write`, sans shell : ni `git`, ni push. `Edit` et `Write` refusent tout chemin hors du clone (`blockWritesOutsideWorkingDirectories`). Le clone n'a pas de dossier `.git` : le dépôt git de l'opération est à côté de lui (`GIT_DIR`), hors de portée de Claude et des commandes npm, et le tracker lance `git` sans hook (`core.hooksPath`) ni moniteur de fichiers (`core.fsmonitor`) ; un hook posé dans le clone par un paquet (husky…) ou par un script d'installation ne s'exécute donc jamais sur le serveur. Claude lance les gestionnaires de paquets par les outils d'un second serveur MCP, `packages`, que le tracker lui fournit (`dist/src/package-tools.js`) avec les seuls outils des gestionnaires des projets du dépôt ; pour npm : `npm_install_lockfile` (`npm install --package-lock-only --ignore-scripts`, avec les paquets à ajouter ou monter), `npm_audit` (avec le périmètre de l'opération), `npm_ci`, `npm_test`, `npm_run` (un script de `package.json`), `npm_ls` et `tsc` (`npm exec --no -- tsc --noEmit`) ; pour pnpm : `pnpm_install_lockfile` (`pnpm install --lockfile-only --ignore-scripts`), `pnpm_audit`, `pnpm_install` (`--frozen-lockfile`), `pnpm_test` (`pnpm -r --if-present run test`), `pnpm_run` (un script, à la racine ou dans un paquet du workspace avec `--filter`) et `pnpm_why` (`pnpm why -r`) ; pour Composer : `composer_update_lock` (`composer update <paquets> --with-all-dependencies --no-install --no-scripts --no-plugins --ignore-platform-req=ext-*`, paquets obligatoires), `composer_audit`, `composer_install`, `composer_test` (`composer run-script test`), `composer_run` (un script de `composer.json`) et `composer_why` (`composer depends --locked --tree`). L'image n'a que les extensions par défaut de l'image officielle de PHP : une extension manquante à l'installation ou aux tests est signalée dans le rapport, pas corrigée. Chaque outil lance une commande fixe dans un dossier du clone qui contient un `package.json` ; ses arguments ne sont que des noms de paquets ou de scripts. Le bac à sable de Claude Code garde en lecture seule les manifestes, les lockfiles et `node_modules` : ces commandes tournent donc hors de lui, chacune dans un conteneur jetable du tracker, comme ses propres `npm audit` et `npm audit fix` (voir [Une opération](#une-opération)) : le code du projet et de ses paquets, `.npmrc` compris, ne s'exécute jamais sur le serveur, et le conteneur ne voit que le clone et le cache de l'opération, sans aucun token. Claude Code ne reçoit jamais `GITHUB_TOKEN`, et `CLAUDE_CODE_SUBPROCESS_ENV_SCRUB` retire son propre token de l'environnement des processus qu'il lance ; sous Linux, cette variable active d'office le bac à sable de Claude Code, qui refuse alors de démarrer sans bubblewrap. Installez-le sur le serveur (`sudo apt-get install -y bubblewrap socat`). Avant chaque session de Claude, le tracker crée un bac à sable d'essai avec le compte et les restrictions du serveur ; s'il échoue, la session est refusée avec la raison : `bwrap` absent, restriction AppArmor des espaces de noms utilisateur (`kernel.apparmor_restrict_unprivileged_userns`, Ubuntu 24.04 et suivantes) ou durcissement du service (`RestrictNamespaces`, `PrivateUsers`, `SystemCallFilter`). Côté organizer, seuls `create_task`, `set_assignees` et `set_tags` sont autorisés : Claude ne lit aucune autre tâche de l'espace, dont le contenu ne peut donc pas finir dans la pull request ; tout autre appel est refusé (`--permission-mode dontAsk`). La consigne précise que les fichiers du dépôt, les sorties de npm et les avis de sécurité sont des données à analyser, jamais des instructions, et demande de signaler dans la tâche tout texte qui tenterait de le détourner, et les réglages Claude du dépôt cloné ne sont pas lus (`--setting-sources user`). Installer les dépendances et lancer les tests exécute le code du projet et de ses paquets dans le clone, à chaque correction par Claude. La configuration MCP, qui porte le token de l'organizer, est écrite hors du clone et supprimée en fin de session. Pour garder en lecture seule `.npmrc`, `.yarnrc`, `.yarnrc.yml`, `bunfig.toml`, `.gitmodules`, `yarn.lock` et `pnpm-lock.yaml`, le bac à sable de Claude Code les crée vides dans le clone quand le dépôt n'en a pas : ces fichiers vides sont retirés avant le commit des corrections.
|
|
270
|
+
**Ce que Claude peut faire** — outils intégrés `Read`, `Grep`, `Glob`, `Edit` et `Write`, sans shell : ni `git`, ni push. `Edit` et `Write` refusent tout chemin hors du clone (`blockWritesOutsideWorkingDirectories`). Le clone n'a pas de dossier `.git` : le dépôt git de l'opération est à côté de lui (`GIT_DIR`), hors de portée de Claude et des commandes npm, et le tracker lance `git` sans hook (`core.hooksPath`) ni moniteur de fichiers (`core.fsmonitor`) ; un hook posé dans le clone par un paquet (husky…) ou par un script d'installation ne s'exécute donc jamais sur le serveur. Claude lance les gestionnaires de paquets par les outils d'un second serveur MCP, `packages`, que le tracker lui fournit (`dist/src/package-tools.js`) avec les seuls outils des gestionnaires des projets du dépôt, et avec les variables système du serveur (`HOME`, `XDG_RUNTIME_DIR`, `PATH`, proxy), qui remplacent celles de Claude Code : Podman rootless y retrouve le stockage du compte du serveur, où sont ses images ; pour npm : `npm_install_lockfile` (`npm install --package-lock-only --ignore-scripts`, avec les paquets à ajouter ou monter), `npm_audit` (avec le périmètre de l'opération), `npm_ci`, `npm_test`, `npm_run` (un script de `package.json`), `npm_ls` et `tsc` (`npm exec --no -- tsc --noEmit`) ; pour pnpm : `pnpm_install_lockfile` (`pnpm install --lockfile-only --ignore-scripts`), `pnpm_audit`, `pnpm_install` (`--frozen-lockfile`), `pnpm_test` (`pnpm -r --if-present run test`), `pnpm_run` (un script, à la racine ou dans un paquet du workspace avec `--filter`) et `pnpm_why` (`pnpm why -r`) ; pour Composer : `composer_update_lock` (`composer update <paquets> --with-all-dependencies --no-install --no-scripts --no-plugins --ignore-platform-req=ext-*`, paquets obligatoires), `composer_audit`, `composer_install`, `composer_test` (`composer run-script test`), `composer_run` (un script de `composer.json`) et `composer_why` (`composer depends --locked --tree`). L'image n'a que les extensions par défaut de l'image officielle de PHP : une extension manquante à l'installation ou aux tests est signalée dans le rapport, pas corrigée. Chaque outil lance une commande fixe dans un dossier du clone qui contient un `package.json` ; ses arguments ne sont que des noms de paquets ou de scripts. Le bac à sable de Claude Code garde en lecture seule les manifestes, les lockfiles et `node_modules` : ces commandes tournent donc hors de lui, chacune dans un conteneur jetable du tracker, comme ses propres `npm audit` et `npm audit fix` (voir [Une opération](#une-opération)) : le code du projet et de ses paquets, `.npmrc` compris, ne s'exécute jamais sur le serveur, et le conteneur ne voit que le clone et le cache de l'opération, sans aucun token. Claude Code ne reçoit jamais `GITHUB_TOKEN`, et `CLAUDE_CODE_SUBPROCESS_ENV_SCRUB` retire son propre token de l'environnement des processus qu'il lance ; sous Linux, cette variable active d'office le bac à sable de Claude Code, qui refuse alors de démarrer sans bubblewrap. Installez-le sur le serveur (`sudo apt-get install -y bubblewrap socat`). Avant chaque session de Claude, le tracker crée un bac à sable d'essai avec le compte et les restrictions du serveur ; s'il échoue, la session est refusée avec la raison : `bwrap` absent, restriction AppArmor des espaces de noms utilisateur (`kernel.apparmor_restrict_unprivileged_userns`, Ubuntu 24.04 et suivantes) ou durcissement du service (`RestrictNamespaces`, `PrivateUsers`, `SystemCallFilter`). Côté organizer, seuls `create_task`, `set_assignees` et `set_tags` sont autorisés : Claude ne lit aucune autre tâche de l'espace, dont le contenu ne peut donc pas finir dans la pull request ; tout autre appel est refusé (`--permission-mode dontAsk`). La consigne précise que les fichiers du dépôt, les sorties de npm et les avis de sécurité sont des données à analyser, jamais des instructions, et demande de signaler dans la tâche tout texte qui tenterait de le détourner, et les réglages Claude du dépôt cloné ne sont pas lus (`--setting-sources user`). Installer les dépendances et lancer les tests exécute le code du projet et de ses paquets dans le clone, à chaque correction par Claude. La configuration MCP, qui porte le token de l'organizer, est écrite hors du clone et supprimée en fin de session. Pour garder en lecture seule `.npmrc`, `.yarnrc`, `.yarnrc.yml`, `bunfig.toml`, `.gitmodules`, `yarn.lock` et `pnpm-lock.yaml`, le bac à sable de Claude Code les crée vides dans le clone quand le dépôt n'en a pas : ces fichiers vides sont retirés avant le commit des corrections.
|
|
249
271
|
|
|
250
272
|
**Limites** — nombre de tours (`--max-turns`, défaut 40) et durée (défaut 15 min, au-delà de laquelle le tracker arrête Claude Code), réglables dans la GUI.
|
|
251
273
|
|
|
@@ -0,0 +1,28 @@
|
|
|
1
|
+
import readline from "readline";
|
|
2
|
+
/** Lit une ligne sur le terminal sans l'afficher. */
|
|
3
|
+
export function promptHidden(question) {
|
|
4
|
+
return new Promise((resolve) => {
|
|
5
|
+
const rl = readline.createInterface({ input: process.stdin, output: process.stdout, terminal: true });
|
|
6
|
+
const output = rl;
|
|
7
|
+
let muted = false;
|
|
8
|
+
output._writeToOutput = (text) => {
|
|
9
|
+
if (!muted || text.includes("\n"))
|
|
10
|
+
output.output.write(muted ? "\n" : text);
|
|
11
|
+
};
|
|
12
|
+
rl.question(question, (answer) => {
|
|
13
|
+
rl.close();
|
|
14
|
+
resolve(answer);
|
|
15
|
+
});
|
|
16
|
+
muted = true;
|
|
17
|
+
});
|
|
18
|
+
}
|
|
19
|
+
/** Lit une ligne sur le terminal. */
|
|
20
|
+
export function promptLine(question) {
|
|
21
|
+
return new Promise((resolve) => {
|
|
22
|
+
const rl = readline.createInterface({ input: process.stdin, output: process.stdout, terminal: true });
|
|
23
|
+
rl.question(question, (answer) => {
|
|
24
|
+
rl.close();
|
|
25
|
+
resolve(answer.trim());
|
|
26
|
+
});
|
|
27
|
+
});
|
|
28
|
+
}
|
|
@@ -0,0 +1,55 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Commande `setup` : installation complète du serveur sur une machine Linux
|
|
3
|
+
* avec systemd, lancée en root. Elle pose ses questions (adresse publique,
|
|
4
|
+
* port, compte de service, données, nginx et certificat, premier compte), en
|
|
5
|
+
* proposant les valeurs du `.env` existant, puis : installe les paquets
|
|
6
|
+
* manquants, crée le compte de service, lui attribue une plage libre de
|
|
7
|
+
* sous-identifiants et active son lingering, écrit le `.env` (clés générées
|
|
8
|
+
* une fois, puis conservées), crée le premier compte de l'interface, prépare
|
|
9
|
+
* Podman rootless, écrit et démarre l'unité systemd, vérifie que le serveur
|
|
10
|
+
* répond, puis configure nginx et le certificat quand ils sont demandés.
|
|
11
|
+
* Relancée, elle reprend la configuration en place.
|
|
12
|
+
*/
|
|
13
|
+
export declare const SETUP_USAGE = "Usage : mcp-dependabot-tracker setup [options]\n\nInstalle le serveur sur cette machine (Linux, systemd), en root. Les questions\nproposent les valeurs du .env existant ; sans terminal, ou avec --non-interactive,\nchaque r\u00E9ponse vient d'une option, sinon du .env existant ou du d\u00E9faut.\n\n --app-url=<url> adresse publique de l'interface (https://\u2026)\n --port=<n> port d'\u00E9coute, sur 127.0.0.1 [4700]\n --service-user=<compte> compte syst\u00E8me du service [dependabot-tracker]\n --data-dir=<chemin> r\u00E9pertoire des donn\u00E9es [<dossier du compte>/data]\n --nginx=oui|non servir l'adresse publique par nginx [oui en https]\n --certbot=oui|non obtenir le certificat avec certbot [oui avec nginx]\n --admin-email=<adresse> premier compte de l'interface\n --admin-name=<nom> nom affich\u00E9 de ce compte\n --non-interactive ne rien demander\n\nLe mot de passe du compte n'est jamais un argument : il est saisi sans \u00E9cho, ou\nlu dans SETUP_ADMIN_PASSWORD.";
|
|
14
|
+
declare const VALUE_OPTIONS: readonly ["app-url", "port", "service-user", "data-dir", "nginx", "certbot", "admin-email", "admin-name"];
|
|
15
|
+
type ValueOption = (typeof VALUE_OPTIONS)[number];
|
|
16
|
+
/** Paquets nécessaires au serveur : git, Podman rootless, et le bac à sable de Claude Code. */
|
|
17
|
+
export declare const BASE_PACKAGES: string[];
|
|
18
|
+
/** Résultat d'une commande système. */
|
|
19
|
+
export interface CommandOutcome {
|
|
20
|
+
code: number;
|
|
21
|
+
stdout: string;
|
|
22
|
+
stderr: string;
|
|
23
|
+
}
|
|
24
|
+
/** Ce que la commande touche sur la machine ; remplaçable dans les tests. */
|
|
25
|
+
export interface SetupHost {
|
|
26
|
+
platform: NodeJS.Platform;
|
|
27
|
+
isRoot: boolean;
|
|
28
|
+
interactive: boolean;
|
|
29
|
+
/** Racine des fichiers système (`/etc`, `/run`) : `/` sur la machine. */
|
|
30
|
+
root: string;
|
|
31
|
+
packageRoot: string;
|
|
32
|
+
nodePath: string;
|
|
33
|
+
/** Lance une commande ; `inherit` montre sa sortie à l'utilisateur. */
|
|
34
|
+
run: (command: string, args: string[], options?: {
|
|
35
|
+
cwd?: string;
|
|
36
|
+
env?: Record<string, string>;
|
|
37
|
+
inherit?: boolean;
|
|
38
|
+
}) => CommandOutcome;
|
|
39
|
+
ask: (question: string) => Promise<string>;
|
|
40
|
+
askSecret: (question: string) => Promise<string>;
|
|
41
|
+
say: (line: string) => void;
|
|
42
|
+
/** Attend que le serveur réponde sur `port` ; rend faux après `timeoutMs`. */
|
|
43
|
+
waitHealthy: (port: number, timeoutMs: number) => Promise<boolean>;
|
|
44
|
+
}
|
|
45
|
+
/** Machine réelle : commandes, terminal et fichiers de la machine. */
|
|
46
|
+
export declare function realHost(packageRoot: string): SetupHost;
|
|
47
|
+
interface ParsedArgs {
|
|
48
|
+
values: Partial<Record<ValueOption, string>>;
|
|
49
|
+
nonInteractive: boolean;
|
|
50
|
+
}
|
|
51
|
+
/** Lit les options `--nom=valeur` ; une option inconnue ou répétée est refusée. */
|
|
52
|
+
export declare function parseSetupArgs(argv: readonly string[]): ParsedArgs;
|
|
53
|
+
/** Exécute la commande ; rend le code de sortie. */
|
|
54
|
+
export declare function runSetup(argv: readonly string[], host: SetupHost): Promise<number>;
|
|
55
|
+
export {};
|
|
@@ -0,0 +1,484 @@
|
|
|
1
|
+
import { spawnSync } from "child_process";
|
|
2
|
+
import fs from "fs";
|
|
3
|
+
import path from "path";
|
|
4
|
+
import dotenv from "dotenv";
|
|
5
|
+
import { addUser, closeAuth, createAuth, generateAuthSecret, listUsers, migrateAuth } from "../core/auth.js";
|
|
6
|
+
import { readServerConfig } from "../core/server-config.js";
|
|
7
|
+
import { SERVICE_NAME, mergeEnvFile, nextFreeSubIdRange, renderNginxSite, renderSystemdUnit, subIdRangesOf, } from "../core/setup-files.js";
|
|
8
|
+
import { generateVaultKey } from "../core/vault.js";
|
|
9
|
+
import { promptHidden, promptLine } from "./prompt.js";
|
|
10
|
+
/**
|
|
11
|
+
* Commande `setup` : installation complète du serveur sur une machine Linux
|
|
12
|
+
* avec systemd, lancée en root. Elle pose ses questions (adresse publique,
|
|
13
|
+
* port, compte de service, données, nginx et certificat, premier compte), en
|
|
14
|
+
* proposant les valeurs du `.env` existant, puis : installe les paquets
|
|
15
|
+
* manquants, crée le compte de service, lui attribue une plage libre de
|
|
16
|
+
* sous-identifiants et active son lingering, écrit le `.env` (clés générées
|
|
17
|
+
* une fois, puis conservées), crée le premier compte de l'interface, prépare
|
|
18
|
+
* Podman rootless, écrit et démarre l'unité systemd, vérifie que le serveur
|
|
19
|
+
* répond, puis configure nginx et le certificat quand ils sont demandés.
|
|
20
|
+
* Relancée, elle reprend la configuration en place.
|
|
21
|
+
*/
|
|
22
|
+
export const SETUP_USAGE = `Usage : mcp-dependabot-tracker setup [options]
|
|
23
|
+
|
|
24
|
+
Installe le serveur sur cette machine (Linux, systemd), en root. Les questions
|
|
25
|
+
proposent les valeurs du .env existant ; sans terminal, ou avec --non-interactive,
|
|
26
|
+
chaque réponse vient d'une option, sinon du .env existant ou du défaut.
|
|
27
|
+
|
|
28
|
+
--app-url=<url> adresse publique de l'interface (https://…)
|
|
29
|
+
--port=<n> port d'écoute, sur 127.0.0.1 [4700]
|
|
30
|
+
--service-user=<compte> compte système du service [${SERVICE_NAME}]
|
|
31
|
+
--data-dir=<chemin> répertoire des données [<dossier du compte>/data]
|
|
32
|
+
--nginx=oui|non servir l'adresse publique par nginx [oui en https]
|
|
33
|
+
--certbot=oui|non obtenir le certificat avec certbot [oui avec nginx]
|
|
34
|
+
--admin-email=<adresse> premier compte de l'interface
|
|
35
|
+
--admin-name=<nom> nom affiché de ce compte
|
|
36
|
+
--non-interactive ne rien demander
|
|
37
|
+
|
|
38
|
+
Le mot de passe du compte n'est jamais un argument : il est saisi sans écho, ou
|
|
39
|
+
lu dans SETUP_ADMIN_PASSWORD.`;
|
|
40
|
+
const VALUE_OPTIONS = ["app-url", "port", "service-user", "data-dir", "nginx", "certbot", "admin-email", "admin-name"];
|
|
41
|
+
/** Paquets nécessaires au serveur : git, Podman rootless, et le bac à sable de Claude Code. */
|
|
42
|
+
export const BASE_PACKAGES = ["git", "podman", "uidmap", "passt", "slirp4netns", "catatonit", "bubblewrap", "socat"];
|
|
43
|
+
const DEFAULT_PORT = "4700";
|
|
44
|
+
const MIN_PASSWORD_LENGTH = 12;
|
|
45
|
+
const HEALTH_TIMEOUT_MS = 30_000;
|
|
46
|
+
const RUNTIME_DIR_TIMEOUT_MS = 10_000;
|
|
47
|
+
class SetupError extends Error {
|
|
48
|
+
}
|
|
49
|
+
function fail(message) {
|
|
50
|
+
throw new SetupError(message);
|
|
51
|
+
}
|
|
52
|
+
/** Machine réelle : commandes, terminal et fichiers de la machine. */
|
|
53
|
+
export function realHost(packageRoot) {
|
|
54
|
+
return {
|
|
55
|
+
platform: process.platform,
|
|
56
|
+
isRoot: typeof process.getuid === "function" && process.getuid() === 0,
|
|
57
|
+
interactive: process.stdin.isTTY === true,
|
|
58
|
+
root: "/",
|
|
59
|
+
packageRoot,
|
|
60
|
+
nodePath: process.execPath,
|
|
61
|
+
run: (command, args, options = {}) => {
|
|
62
|
+
const result = spawnSync(command, args, {
|
|
63
|
+
cwd: options.cwd,
|
|
64
|
+
env: { ...process.env, ...options.env },
|
|
65
|
+
encoding: "utf-8",
|
|
66
|
+
stdio: options.inherit ? ["ignore", "inherit", "inherit"] : ["ignore", "pipe", "pipe"],
|
|
67
|
+
});
|
|
68
|
+
if (result.error)
|
|
69
|
+
return { code: 127, stdout: "", stderr: result.error.message };
|
|
70
|
+
return { code: result.status ?? 1, stdout: result.stdout ?? "", stderr: result.stderr ?? "" };
|
|
71
|
+
},
|
|
72
|
+
ask: (question) => promptLine(`${question} : `),
|
|
73
|
+
askSecret: (question) => promptHidden(`${question} : `),
|
|
74
|
+
say: (line) => process.stdout.write(`${line}\n`),
|
|
75
|
+
waitHealthy: async (port, timeoutMs) => {
|
|
76
|
+
const deadline = Date.now() + timeoutMs;
|
|
77
|
+
while (Date.now() < deadline) {
|
|
78
|
+
const ok = await fetch(`http://127.0.0.1:${port}/health`).then((response) => response.ok, () => false);
|
|
79
|
+
if (ok)
|
|
80
|
+
return true;
|
|
81
|
+
await new Promise((resolve) => setTimeout(resolve, 1000));
|
|
82
|
+
}
|
|
83
|
+
return false;
|
|
84
|
+
},
|
|
85
|
+
};
|
|
86
|
+
}
|
|
87
|
+
/** Lit les options `--nom=valeur` ; une option inconnue ou répétée est refusée. */
|
|
88
|
+
export function parseSetupArgs(argv) {
|
|
89
|
+
const values = {};
|
|
90
|
+
let nonInteractive = false;
|
|
91
|
+
for (const arg of argv) {
|
|
92
|
+
if (arg === "--non-interactive") {
|
|
93
|
+
nonInteractive = true;
|
|
94
|
+
continue;
|
|
95
|
+
}
|
|
96
|
+
const match = /^--([a-z-]+)=(.*)$/.exec(arg);
|
|
97
|
+
if (!match)
|
|
98
|
+
fail(`Argument inattendu : « ${arg} ».\n\n${SETUP_USAGE}`);
|
|
99
|
+
const [, name, value] = match;
|
|
100
|
+
if (name === "admin-password" || name === "password")
|
|
101
|
+
fail("Le mot de passe ne se passe pas en argument, qui reste lisible dans l'historique et la liste des processus : saisissez-le, ou définissez SETUP_ADMIN_PASSWORD.");
|
|
102
|
+
if (!VALUE_OPTIONS.includes(name))
|
|
103
|
+
fail(`Option inconnue : --${name}.\n\n${SETUP_USAGE}`);
|
|
104
|
+
if (values[name] !== undefined)
|
|
105
|
+
fail(`--${name} est donné plusieurs fois.`);
|
|
106
|
+
values[name] = value.trim();
|
|
107
|
+
}
|
|
108
|
+
return { values, nonInteractive };
|
|
109
|
+
}
|
|
110
|
+
class Prompter {
|
|
111
|
+
host;
|
|
112
|
+
args;
|
|
113
|
+
constructor(host, args) {
|
|
114
|
+
this.host = host;
|
|
115
|
+
this.args = args;
|
|
116
|
+
}
|
|
117
|
+
get interactive() {
|
|
118
|
+
return this.host.interactive && !this.args.nonInteractive;
|
|
119
|
+
}
|
|
120
|
+
provided(option) {
|
|
121
|
+
return this.args.values[option];
|
|
122
|
+
}
|
|
123
|
+
/** Réponse : option, puis saisie (valeur proposée sur Entrée), ou valeur proposée sans terminal. */
|
|
124
|
+
async value(spec) {
|
|
125
|
+
const given = this.provided(spec.option);
|
|
126
|
+
if (given !== undefined) {
|
|
127
|
+
try {
|
|
128
|
+
const value = spec.validate(given);
|
|
129
|
+
this.host.say(` ${spec.question} : ${given}`);
|
|
130
|
+
return value;
|
|
131
|
+
}
|
|
132
|
+
catch (err) {
|
|
133
|
+
fail(`--${spec.option} : ${err.message}`);
|
|
134
|
+
}
|
|
135
|
+
}
|
|
136
|
+
if (!this.interactive) {
|
|
137
|
+
if (spec.proposed === undefined)
|
|
138
|
+
fail(`Sans terminal, --${spec.option} est requis (${spec.question.toLowerCase()}).`);
|
|
139
|
+
try {
|
|
140
|
+
const value = spec.validate(spec.proposed);
|
|
141
|
+
this.host.say(` ${spec.question} : ${spec.proposed}`);
|
|
142
|
+
return value;
|
|
143
|
+
}
|
|
144
|
+
catch (err) {
|
|
145
|
+
fail(`${spec.question} : la valeur ${spec.proposed} est invalide, ${err.message} Passez --${spec.option}.`);
|
|
146
|
+
}
|
|
147
|
+
}
|
|
148
|
+
for (;;) {
|
|
149
|
+
const raw = await this.host.ask(`${spec.question}${spec.proposed !== undefined ? ` [${spec.proposed}]` : ""}`);
|
|
150
|
+
const candidate = raw === "" ? spec.proposed : raw;
|
|
151
|
+
if (candidate === undefined) {
|
|
152
|
+
this.host.say(" ! Une réponse est attendue.");
|
|
153
|
+
continue;
|
|
154
|
+
}
|
|
155
|
+
try {
|
|
156
|
+
return spec.validate(candidate);
|
|
157
|
+
}
|
|
158
|
+
catch (err) {
|
|
159
|
+
this.host.say(` ! ${err.message}`);
|
|
160
|
+
}
|
|
161
|
+
}
|
|
162
|
+
}
|
|
163
|
+
}
|
|
164
|
+
function validateAppUrl(raw) {
|
|
165
|
+
let url;
|
|
166
|
+
try {
|
|
167
|
+
url = new URL(raw);
|
|
168
|
+
}
|
|
169
|
+
catch {
|
|
170
|
+
throw new Error(`« ${raw} » n'est pas une adresse : attendu par exemple https://deps.example.com.`);
|
|
171
|
+
}
|
|
172
|
+
if (url.protocol !== "https:")
|
|
173
|
+
throw new Error("une adresse en https est attendue : le serveur installé est servi derrière un reverse proxy qui porte le certificat.");
|
|
174
|
+
if (url.pathname !== "/" || url.search || url.hash || url.username)
|
|
175
|
+
throw new Error("l'adresse ne doit avoir ni chemin, ni paramètres, ni identifiants : l'interface est servie à la racine.");
|
|
176
|
+
return url;
|
|
177
|
+
}
|
|
178
|
+
function validatePort(raw) {
|
|
179
|
+
const port = Number(raw);
|
|
180
|
+
if (!/^\d+$/.test(raw) || port < 1 || port > 65535)
|
|
181
|
+
throw new Error(`port invalide (${raw}) : un entier entre 1 et 65535.`);
|
|
182
|
+
return port;
|
|
183
|
+
}
|
|
184
|
+
function validateServiceUser(raw) {
|
|
185
|
+
if (!/^[a-z_][a-z0-9_-]{0,31}$/.test(raw))
|
|
186
|
+
throw new Error(`compte invalide (${raw}) : minuscules, chiffres, « _ » et « - ».`);
|
|
187
|
+
return raw;
|
|
188
|
+
}
|
|
189
|
+
function validateAbsolutePath(raw) {
|
|
190
|
+
if (!path.isAbsolute(raw))
|
|
191
|
+
throw new Error(`chemin absolu attendu (${raw}).`);
|
|
192
|
+
return path.resolve(raw);
|
|
193
|
+
}
|
|
194
|
+
function validateBoolean(raw) {
|
|
195
|
+
const value = raw.trim().toLowerCase();
|
|
196
|
+
if (["o", "oui", "y", "yes"].includes(value))
|
|
197
|
+
return true;
|
|
198
|
+
if (["n", "non", "no"].includes(value))
|
|
199
|
+
return false;
|
|
200
|
+
throw new Error(`réponse invalide (${raw}) : oui ou non.`);
|
|
201
|
+
}
|
|
202
|
+
function validateEmail(raw) {
|
|
203
|
+
if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(raw))
|
|
204
|
+
throw new Error(`adresse e-mail invalide (${raw}).`);
|
|
205
|
+
return raw.toLowerCase();
|
|
206
|
+
}
|
|
207
|
+
function validateName(raw) {
|
|
208
|
+
if (raw.trim() === "")
|
|
209
|
+
throw new Error("nom vide.");
|
|
210
|
+
return raw.trim();
|
|
211
|
+
}
|
|
212
|
+
// --- Système -------------------------------------------------------------------
|
|
213
|
+
/** Chemin d'un fichier système sous la racine de l'hôte. */
|
|
214
|
+
function sys(host, file) {
|
|
215
|
+
return path.join(host.root, file);
|
|
216
|
+
}
|
|
217
|
+
function readIfExists(file) {
|
|
218
|
+
return fs.existsSync(file) ? fs.readFileSync(file, "utf-8") : undefined;
|
|
219
|
+
}
|
|
220
|
+
/** Lance une commande et lève une erreur qui cite sa sortie si elle échoue. */
|
|
221
|
+
function must(host, command, args, options = {}) {
|
|
222
|
+
const result = host.run(command, args, options);
|
|
223
|
+
if (result.code !== 0) {
|
|
224
|
+
const output = `${result.stderr}\n${result.stdout}`.trim().split("\n").slice(-6).join("\n");
|
|
225
|
+
fail(`« ${[command, ...args].join(" ")} » a échoué (code ${result.code})${output ? ` :\n${output}` : "."}`);
|
|
226
|
+
}
|
|
227
|
+
return result;
|
|
228
|
+
}
|
|
229
|
+
/** Compte système d'après `getent passwd`, ou null s'il n'existe pas. */
|
|
230
|
+
function accountOf(host, user) {
|
|
231
|
+
const result = host.run("getent", ["passwd", user]);
|
|
232
|
+
if (result.code !== 0)
|
|
233
|
+
return null;
|
|
234
|
+
const [, , uid, gid, , home] = result.stdout.trim().split(":");
|
|
235
|
+
return { uid: Number(uid), gid: Number(gid), home };
|
|
236
|
+
}
|
|
237
|
+
/** Paquets de `wanted` qui ne sont pas installés. */
|
|
238
|
+
function missingPackages(host, wanted) {
|
|
239
|
+
return wanted.filter((name) => !host.run("dpkg-query", ["-W", "-f=${Status}", name]).stdout.includes("install ok installed"));
|
|
240
|
+
}
|
|
241
|
+
async function waitFor(check, timeoutMs) {
|
|
242
|
+
const deadline = Date.now() + timeoutMs;
|
|
243
|
+
for (;;) {
|
|
244
|
+
if (check())
|
|
245
|
+
return true;
|
|
246
|
+
if (Date.now() >= deadline)
|
|
247
|
+
return false;
|
|
248
|
+
await new Promise((resolve) => setTimeout(resolve, 200));
|
|
249
|
+
}
|
|
250
|
+
}
|
|
251
|
+
/** Site nginx déjà activé, autre que celui du tracker, qui sert `hostname`. */
|
|
252
|
+
function nginxSiteServing(host, hostname) {
|
|
253
|
+
const dir = sys(host, "/etc/nginx/sites-enabled");
|
|
254
|
+
if (!fs.existsSync(dir))
|
|
255
|
+
return null;
|
|
256
|
+
const pattern = new RegExp(`server_name[^;]*\\s${hostname.replace(/\./g, "\\.")}[\\s;]`);
|
|
257
|
+
for (const entry of fs.readdirSync(dir)) {
|
|
258
|
+
if (entry === SERVICE_NAME)
|
|
259
|
+
continue;
|
|
260
|
+
const text = readIfExists(path.join(dir, entry));
|
|
261
|
+
if (text !== undefined && pattern.test(text))
|
|
262
|
+
return path.join("/etc/nginx/sites-enabled", entry);
|
|
263
|
+
}
|
|
264
|
+
return null;
|
|
265
|
+
}
|
|
266
|
+
async function readPassword(host, prompter) {
|
|
267
|
+
const fromEnv = process.env.SETUP_ADMIN_PASSWORD;
|
|
268
|
+
if (fromEnv) {
|
|
269
|
+
if (fromEnv.length < MIN_PASSWORD_LENGTH)
|
|
270
|
+
fail(`SETUP_ADMIN_PASSWORD doit faire au moins ${MIN_PASSWORD_LENGTH} caractères.`);
|
|
271
|
+
host.say(" Mot de passe : repris de SETUP_ADMIN_PASSWORD.");
|
|
272
|
+
return fromEnv;
|
|
273
|
+
}
|
|
274
|
+
if (!prompter.interactive)
|
|
275
|
+
fail("Sans terminal, SETUP_ADMIN_PASSWORD est requis pour créer le compte.");
|
|
276
|
+
for (;;) {
|
|
277
|
+
const first = await host.askSecret(`Mot de passe, non affiché (${MIN_PASSWORD_LENGTH} caractères minimum)`);
|
|
278
|
+
if (first.length < MIN_PASSWORD_LENGTH) {
|
|
279
|
+
host.say(` ! Au moins ${MIN_PASSWORD_LENGTH} caractères.`);
|
|
280
|
+
continue;
|
|
281
|
+
}
|
|
282
|
+
if ((await host.askSecret("Confirmation")) !== first) {
|
|
283
|
+
host.say(" ! Les deux saisies diffèrent.");
|
|
284
|
+
continue;
|
|
285
|
+
}
|
|
286
|
+
return first;
|
|
287
|
+
}
|
|
288
|
+
}
|
|
289
|
+
/** Comptes de l'interface déjà créés dans `dataDir`. */
|
|
290
|
+
async function existingAccounts(dataDir, env) {
|
|
291
|
+
if (!fs.existsSync(path.join(dataDir, "auth.sqlite")))
|
|
292
|
+
return 0;
|
|
293
|
+
const auth = createAuth(dataDir, readServerConfig(env));
|
|
294
|
+
try {
|
|
295
|
+
await migrateAuth(auth);
|
|
296
|
+
return (await listUsers(auth)).length;
|
|
297
|
+
}
|
|
298
|
+
finally {
|
|
299
|
+
closeAuth(auth);
|
|
300
|
+
}
|
|
301
|
+
}
|
|
302
|
+
async function planAccount(host, prompter, count) {
|
|
303
|
+
if (count > 0 && prompter.provided("admin-email") === undefined) {
|
|
304
|
+
const answer = prompter.interactive ? await host.ask(`${count} compte(s) existe(nt) déjà. Adresse d'un compte à ajouter (Entrée pour aucun)`) : "";
|
|
305
|
+
if (answer === "") {
|
|
306
|
+
host.say(` Comptes : inchangés (${count}).`);
|
|
307
|
+
return null;
|
|
308
|
+
}
|
|
309
|
+
const email = validateEmail(answer);
|
|
310
|
+
return { email, name: await prompter.value({ option: "admin-name", question: "Nom affiché", validate: validateName }), password: await readPassword(host, prompter) };
|
|
311
|
+
}
|
|
312
|
+
const email = await prompter.value({ option: "admin-email", question: "Adresse e-mail du premier compte", validate: validateEmail });
|
|
313
|
+
const name = await prompter.value({ option: "admin-name", question: "Nom affiché", validate: validateName });
|
|
314
|
+
return { email, name, password: await readPassword(host, prompter) };
|
|
315
|
+
}
|
|
316
|
+
/** Exécute la commande ; rend le code de sortie. */
|
|
317
|
+
export async function runSetup(argv, host) {
|
|
318
|
+
const step = (title) => host.say(`\n== ${title}`);
|
|
319
|
+
try {
|
|
320
|
+
const args = parseSetupArgs(argv);
|
|
321
|
+
if (host.platform !== "linux")
|
|
322
|
+
fail("setup installe un service systemd : lancez-le sur le serveur Linux qui hébergera le tracker.");
|
|
323
|
+
if (!host.isRoot)
|
|
324
|
+
fail("setup crée un compte système et écrit dans /etc : relancez-le en root (sudo).");
|
|
325
|
+
if (host.run("systemctl", ["--version"]).code !== 0)
|
|
326
|
+
fail("systemd est introuvable (systemctl) : setup installe un service systemd.");
|
|
327
|
+
const prompter = new Prompter(host, args);
|
|
328
|
+
const envFile = path.join(host.packageRoot, ".env");
|
|
329
|
+
const existingText = readIfExists(envFile);
|
|
330
|
+
const existing = existingText === undefined ? {} : dotenv.parse(existingText);
|
|
331
|
+
const kept = (key) => (existing[key] ? existing[key] : undefined);
|
|
332
|
+
host.say("Dependabot Tracker — installation du serveur");
|
|
333
|
+
host.say(existingText === undefined ? ` Nouvelle configuration : ${envFile}` : ` Configuration existante reprise : ${envFile}`);
|
|
334
|
+
step("Adresse");
|
|
335
|
+
const appUrl = await prompter.value({ option: "app-url", question: "Adresse publique de l'interface", proposed: kept("APP_URL"), validate: validateAppUrl });
|
|
336
|
+
const port = await prompter.value({ option: "port", question: "Port d'écoute (sur 127.0.0.1)", proposed: kept("APP_PORT") ?? DEFAULT_PORT, validate: validatePort });
|
|
337
|
+
step("Compte de service et données");
|
|
338
|
+
const serviceUser = await prompter.value({ option: "service-user", question: "Compte système du service", proposed: SERVICE_NAME, validate: validateServiceUser });
|
|
339
|
+
const current = accountOf(host, serviceUser);
|
|
340
|
+
const home = current?.home ?? `/var/lib/${serviceUser}`;
|
|
341
|
+
const dataDir = await prompter.value({ option: "data-dir", question: "Répertoire des données", proposed: kept("DATA_DIR") ?? `${home}/data`, validate: validateAbsolutePath });
|
|
342
|
+
step("Reverse proxy");
|
|
343
|
+
const nginx = await prompter.value({ option: "nginx", question: `Servir ${appUrl.hostname} par nginx`, proposed: "oui", validate: validateBoolean });
|
|
344
|
+
const servedBy = nginx ? nginxSiteServing(host, appUrl.hostname) : null;
|
|
345
|
+
if (servedBy)
|
|
346
|
+
host.say(` nginx sert déjà ${appUrl.hostname} (${servedBy}) : ce site est gardé tel quel.`);
|
|
347
|
+
const certbot = nginx && !servedBy ? await prompter.value({ option: "certbot", question: "Obtenir le certificat avec certbot", proposed: "oui", validate: validateBoolean }) : false;
|
|
348
|
+
if (!nginx)
|
|
349
|
+
host.say(` Le reverse proxy qui porte le certificat de ${appUrl.hostname} doit joindre 127.0.0.1:${port}.`);
|
|
350
|
+
const values = {
|
|
351
|
+
DATA_DIR: dataDir,
|
|
352
|
+
APP_URL: appUrl.origin,
|
|
353
|
+
APP_PORT: String(port),
|
|
354
|
+
AUTH_SECRET: kept("AUTH_SECRET") ?? generateAuthSecret(),
|
|
355
|
+
VAULT_KEY: kept("VAULT_KEY") ?? generateVaultKey(),
|
|
356
|
+
TRUSTED_PROXIES: kept("TRUSTED_PROXIES") ?? "127.0.0.1",
|
|
357
|
+
};
|
|
358
|
+
const env = { ...existing, ...values };
|
|
359
|
+
try {
|
|
360
|
+
readServerConfig(env);
|
|
361
|
+
}
|
|
362
|
+
catch (err) {
|
|
363
|
+
fail(err.message);
|
|
364
|
+
}
|
|
365
|
+
step("Premier compte de l'interface");
|
|
366
|
+
const account = await planAccount(host, prompter, await existingAccounts(dataDir, env));
|
|
367
|
+
const certbotEmail = certbot ? (account?.email ?? (await prompter.value({ option: "admin-email", question: "Adresse e-mail pour Let's Encrypt", validate: validateEmail }))) : null;
|
|
368
|
+
if (prompter.interactive) {
|
|
369
|
+
const go = validateBoolean((await host.ask("\nTout est prêt. Lancer l'installation ? [oui]")) || "oui");
|
|
370
|
+
if (!go)
|
|
371
|
+
fail("installation abandonnée, rien n'a été modifié.");
|
|
372
|
+
}
|
|
373
|
+
step("Paquets");
|
|
374
|
+
const packages = [...BASE_PACKAGES, ...(nginx && !servedBy ? ["nginx"] : []), ...(certbot ? ["certbot", "python3-certbot-nginx"] : [])];
|
|
375
|
+
const missing = missingPackages(host, packages);
|
|
376
|
+
if (missing.length === 0)
|
|
377
|
+
host.say(" Tous présents.");
|
|
378
|
+
else {
|
|
379
|
+
host.say(` Installation : ${missing.join(" ")}`);
|
|
380
|
+
must(host, "apt-get", ["update"], { inherit: true, env: { DEBIAN_FRONTEND: "noninteractive" } });
|
|
381
|
+
must(host, "apt-get", ["install", "-y", ...missing], { inherit: true, env: { DEBIAN_FRONTEND: "noninteractive" } });
|
|
382
|
+
}
|
|
383
|
+
step("Compte de service");
|
|
384
|
+
if (current)
|
|
385
|
+
host.say(` ${serviceUser} existe (uid ${current.uid}, ${current.home}).`);
|
|
386
|
+
else {
|
|
387
|
+
must(host, "useradd", ["--system", "--user-group", "--create-home", "--home-dir", home, "--shell", "/usr/sbin/nologin", serviceUser]);
|
|
388
|
+
host.say(` ${serviceUser} créé (${home}).`);
|
|
389
|
+
}
|
|
390
|
+
const accountInfo = accountOf(host, serviceUser) ?? fail(`le compte ${serviceUser} est introuvable après sa création.`);
|
|
391
|
+
const group = must(host, "id", ["-gn", serviceUser]).stdout.trim();
|
|
392
|
+
const subuid = readIfExists(sys(host, "/etc/subuid")) ?? "";
|
|
393
|
+
const subgid = readIfExists(sys(host, "/etc/subgid")) ?? "";
|
|
394
|
+
if (subIdRangesOf(subuid, serviceUser).length > 0 && subIdRangesOf(subgid, serviceUser).length > 0) {
|
|
395
|
+
host.say(" Sous-identifiants : plage déjà attribuée.");
|
|
396
|
+
}
|
|
397
|
+
else {
|
|
398
|
+
const range = nextFreeSubIdRange(subuid, subgid);
|
|
399
|
+
const spec = `${range.start}-${range.start + range.count - 1}`;
|
|
400
|
+
must(host, "usermod", ["--add-subuids", spec, "--add-subgids", spec, serviceUser]);
|
|
401
|
+
host.say(` Sous-identifiants : ${spec}.`);
|
|
402
|
+
}
|
|
403
|
+
must(host, "loginctl", ["enable-linger", serviceUser]);
|
|
404
|
+
const runtimeDir = `/run/user/${accountInfo.uid}`;
|
|
405
|
+
if (!(await waitFor(() => fs.existsSync(sys(host, runtimeDir)), RUNTIME_DIR_TIMEOUT_MS))) {
|
|
406
|
+
fail(`${runtimeDir} n'existe pas malgré le lingering : vérifiez « loginctl show-user ${serviceUser} ».`);
|
|
407
|
+
}
|
|
408
|
+
host.say(` Lingering actif (${runtimeDir}).`);
|
|
409
|
+
step("Configuration");
|
|
410
|
+
fs.mkdirSync(dataDir, { recursive: true, mode: 0o700 });
|
|
411
|
+
fs.writeFileSync(envFile, mergeEnvFile(existingText, values), { mode: 0o640 });
|
|
412
|
+
fs.chmodSync(envFile, 0o640);
|
|
413
|
+
must(host, "chown", [`root:${group}`, envFile]);
|
|
414
|
+
host.say(` ${envFile} (lisible par root et ${group} seulement)`);
|
|
415
|
+
if (account) {
|
|
416
|
+
const auth = createAuth(dataDir, readServerConfig(env));
|
|
417
|
+
try {
|
|
418
|
+
await migrateAuth(auth);
|
|
419
|
+
const user = await addUser(auth, account);
|
|
420
|
+
host.say(` Compte ${user.email} créé.`);
|
|
421
|
+
}
|
|
422
|
+
finally {
|
|
423
|
+
closeAuth(auth);
|
|
424
|
+
}
|
|
425
|
+
}
|
|
426
|
+
must(host, "chown", ["-R", `${serviceUser}:${group}`, dataDir]);
|
|
427
|
+
step("Podman");
|
|
428
|
+
const asService = (command) => must(host, "runuser", ["-u", serviceUser, "--", "env", `XDG_RUNTIME_DIR=${runtimeDir}`, ...command], { cwd: accountInfo.home });
|
|
429
|
+
asService(["podman", "system", "migrate"]);
|
|
430
|
+
const rootless = asService(["podman", "info", "--format", "{{.Host.Security.Rootless}}"]).stdout.trim();
|
|
431
|
+
if (rootless !== "true")
|
|
432
|
+
fail(`Podman ne tourne pas en rootless sous ${serviceUser} (podman info : ${rootless || "rien"}).`);
|
|
433
|
+
host.say(` Rootless sous ${serviceUser}.`);
|
|
434
|
+
step("Service");
|
|
435
|
+
const layout = { serviceUser, serviceGroup: group, uid: accountInfo.uid, home: accountInfo.home, dataDir, packageRoot: host.packageRoot, nodePath: host.nodePath, port };
|
|
436
|
+
const unitFile = sys(host, `/etc/systemd/system/${SERVICE_NAME}.service`);
|
|
437
|
+
fs.mkdirSync(path.dirname(unitFile), { recursive: true });
|
|
438
|
+
fs.writeFileSync(unitFile, renderSystemdUnit(layout));
|
|
439
|
+
host.say(` /etc/systemd/system/${SERVICE_NAME}.service`);
|
|
440
|
+
const dropIns = sys(host, `/etc/systemd/system/${SERVICE_NAME}.service.d`);
|
|
441
|
+
if (fs.existsSync(dropIns) && fs.readdirSync(dropIns).length > 0) {
|
|
442
|
+
host.say(` Attention : /etc/systemd/system/${SERVICE_NAME}.service.d contient ${fs.readdirSync(dropIns).join(", ")}, qui complète(nt) l'unité.`);
|
|
443
|
+
}
|
|
444
|
+
must(host, "systemctl", ["daemon-reload"]);
|
|
445
|
+
must(host, "systemctl", ["enable", SERVICE_NAME]);
|
|
446
|
+
must(host, "systemctl", ["restart", SERVICE_NAME]);
|
|
447
|
+
if (!(await host.waitHealthy(port, HEALTH_TIMEOUT_MS)))
|
|
448
|
+
fail(`le serveur ne répond pas sur 127.0.0.1:${port} : voyez « journalctl -u ${SERVICE_NAME} -n 50 ».`);
|
|
449
|
+
host.say(` Démarré, répond sur 127.0.0.1:${port}.`);
|
|
450
|
+
if (nginx && !servedBy) {
|
|
451
|
+
step("nginx");
|
|
452
|
+
const site = sys(host, `/etc/nginx/sites-available/${SERVICE_NAME}`);
|
|
453
|
+
const enabled = sys(host, `/etc/nginx/sites-enabled/${SERVICE_NAME}`);
|
|
454
|
+
const existingSite = readIfExists(site);
|
|
455
|
+
if (existingSite === undefined) {
|
|
456
|
+
fs.mkdirSync(path.dirname(site), { recursive: true });
|
|
457
|
+
fs.writeFileSync(site, renderNginxSite(appUrl.hostname, port));
|
|
458
|
+
host.say(` /etc/nginx/sites-available/${SERVICE_NAME}`);
|
|
459
|
+
}
|
|
460
|
+
else
|
|
461
|
+
host.say(` /etc/nginx/sites-available/${SERVICE_NAME} existe : gardé tel quel.`);
|
|
462
|
+
if (!fs.existsSync(enabled))
|
|
463
|
+
must(host, "ln", ["-s", `/etc/nginx/sites-available/${SERVICE_NAME}`, enabled]);
|
|
464
|
+
must(host, "nginx", ["-t"]);
|
|
465
|
+
must(host, "systemctl", ["reload", "nginx"]);
|
|
466
|
+
host.say(" Site activé, nginx rechargé.");
|
|
467
|
+
if (certbot) {
|
|
468
|
+
must(host, "certbot", ["--nginx", "-d", appUrl.hostname, "--non-interactive", "--agree-tos", "-m", certbotEmail, "--redirect", "--keep-until-expiring"], { inherit: true });
|
|
469
|
+
host.say(` Certificat en place pour ${appUrl.hostname}.`);
|
|
470
|
+
}
|
|
471
|
+
}
|
|
472
|
+
step("Terminé");
|
|
473
|
+
host.say(` Interface : ${appUrl.origin}`);
|
|
474
|
+
host.say(` Données : ${dataDir} ; service : systemctl status ${SERVICE_NAME}`);
|
|
475
|
+
host.say(" Reste à faire dans l'interface : le token GitHub du tracker (Réglages › GitHub), puis le token Claude pour les corrections par Claude.");
|
|
476
|
+
if (account)
|
|
477
|
+
host.say(` Protégez le compte par un second facteur : mcp-dependabot-tracker user totp ${account.email}`);
|
|
478
|
+
return 0;
|
|
479
|
+
}
|
|
480
|
+
catch (err) {
|
|
481
|
+
process.stderr.write(`Installation interrompue : ${err?.message ?? err}\n`);
|
|
482
|
+
return 1;
|
|
483
|
+
}
|
|
484
|
+
}
|
package/dist/src/cli/users.js
CHANGED
|
@@ -1,8 +1,8 @@
|
|
|
1
|
-
import readline from "readline";
|
|
2
1
|
import QRCode from "qrcode";
|
|
3
2
|
import { addUser, createAuth, currentTotpCode, disableTotp, enableTotp, listUsers, migrateAuth, prepareTotp, removeUser, setUserPassword } from "../core/auth.js";
|
|
4
3
|
import { resolveDataDir } from "../core/data-dir.js";
|
|
5
4
|
import { readAuthEnv } from "../core/server-config.js";
|
|
5
|
+
import { promptHidden, promptLine } from "./prompt.js";
|
|
6
6
|
export const USERS_USAGE = [
|
|
7
7
|
" mcp-dependabot-tracker user add <email> [--name=<nom>] crée un compte (mot de passe demandé)",
|
|
8
8
|
" mcp-dependabot-tracker user password <email> change le mot de passe et ferme les sessions",
|
|
@@ -10,33 +10,6 @@ export const USERS_USAGE = [
|
|
|
10
10
|
" mcp-dependabot-tracker user remove <email> supprime le compte",
|
|
11
11
|
" mcp-dependabot-tracker user list liste les comptes",
|
|
12
12
|
].join("\n");
|
|
13
|
-
/** Lit une ligne sur le terminal sans l'afficher. */
|
|
14
|
-
function promptHidden(question) {
|
|
15
|
-
return new Promise((resolve) => {
|
|
16
|
-
const rl = readline.createInterface({ input: process.stdin, output: process.stdout, terminal: true });
|
|
17
|
-
const output = rl;
|
|
18
|
-
let muted = false;
|
|
19
|
-
output._writeToOutput = (text) => {
|
|
20
|
-
if (!muted || text.includes("\n"))
|
|
21
|
-
output.output.write(muted ? "\n" : text);
|
|
22
|
-
};
|
|
23
|
-
rl.question(question, (answer) => {
|
|
24
|
-
rl.close();
|
|
25
|
-
resolve(answer);
|
|
26
|
-
});
|
|
27
|
-
muted = true;
|
|
28
|
-
});
|
|
29
|
-
}
|
|
30
|
-
/** Lit une ligne sur le terminal. */
|
|
31
|
-
function promptLine(question) {
|
|
32
|
-
return new Promise((resolve) => {
|
|
33
|
-
const rl = readline.createInterface({ input: process.stdin, output: process.stdout, terminal: true });
|
|
34
|
-
rl.question(question, (answer) => {
|
|
35
|
-
rl.close();
|
|
36
|
-
resolve(answer.trim());
|
|
37
|
-
});
|
|
38
|
-
});
|
|
39
|
-
}
|
|
40
13
|
/** Essais du code de l'application avant l'abandon de l'activation. */
|
|
41
14
|
const TOTP_CONFIRMATION_TRIES = 3;
|
|
42
15
|
/** QR code de `text` en caractères, pour un terminal : deux modules par caractère, sur fond clair. */
|
package/dist/src/core/auth.d.ts
CHANGED
|
@@ -725,6 +725,8 @@ export declare function createAuth(dataDir: string, env: AuthEnv): import("bette
|
|
|
725
725
|
}];
|
|
726
726
|
}>;
|
|
727
727
|
export type Auth = ReturnType<typeof createAuth>;
|
|
728
|
+
/** Ferme la base SQLite d'une instance. */
|
|
729
|
+
export declare function closeAuth(auth: Auth): void;
|
|
728
730
|
/** Crée ou complète les tables de Better Auth. */
|
|
729
731
|
export declare function migrateAuth(auth: Auth): Promise<void>;
|
|
730
732
|
/** Nouveau secret de session : 48 octets aléatoires en base64. */
|
package/dist/src/core/auth.js
CHANGED
|
@@ -70,6 +70,10 @@ export function createAuth(dataDir, env) {
|
|
|
70
70
|
plugins: [twoFactor({ issuer: APP_NAME, totpOptions: { digits: TOTP_DIGITS, period: TOTP_PERIOD_SECONDS } })],
|
|
71
71
|
});
|
|
72
72
|
}
|
|
73
|
+
/** Ferme la base SQLite d'une instance. */
|
|
74
|
+
export function closeAuth(auth) {
|
|
75
|
+
auth.options.database.close();
|
|
76
|
+
}
|
|
73
77
|
/** Crée ou complète les tables de Better Auth. */
|
|
74
78
|
export async function migrateAuth(auth) {
|
|
75
79
|
const { runMigrations } = await getMigrations(auth.options);
|
|
@@ -15,6 +15,8 @@ export declare class CommandAbortedError extends Error {
|
|
|
15
15
|
}
|
|
16
16
|
/** Arrête le processus et ses enfants. */
|
|
17
17
|
export declare function killTree(pid: number): void;
|
|
18
|
+
/** Environnement du serveur transmis aux commandes : les seules variables de `PASSED_ENV`. */
|
|
19
|
+
export declare function inheritedEnv(): NodeJS.ProcessEnv;
|
|
18
20
|
/**
|
|
19
21
|
* Lance une commande sans shell, et attend sa fin. La commande reçoit les
|
|
20
22
|
* variables système du serveur (`PASSED_ENV`), sans aucun de ses secrets, plus
|
|
@@ -64,7 +64,7 @@ const PASSED_ENV = [
|
|
|
64
64
|
"XDG_DATA_HOME",
|
|
65
65
|
];
|
|
66
66
|
/** Environnement du serveur transmis aux commandes : les seules variables de `PASSED_ENV`. */
|
|
67
|
-
function inheritedEnv() {
|
|
67
|
+
export function inheritedEnv() {
|
|
68
68
|
const env = {};
|
|
69
69
|
for (const name of PASSED_ENV) {
|
|
70
70
|
if (process.env[name] !== undefined)
|
|
@@ -32,6 +32,20 @@ export declare function organizerServer(connection: OrganizerConnection): {
|
|
|
32
32
|
ORGANIZER_TOKEN: string;
|
|
33
33
|
};
|
|
34
34
|
};
|
|
35
|
+
/**
|
|
36
|
+
* Lancement du serveur `package-tools` du tracker sur le clone et le cache de
|
|
37
|
+
* l'opération, avec les outils de ses gestionnaires. Il reçoit les variables
|
|
38
|
+
* système du serveur (`HOME`, `XDG_RUNTIME_DIR`…), qui remplacent celles de
|
|
39
|
+
* Claude Code : Podman rootless y trouve le stockage et le dossier
|
|
40
|
+
* d'exécution du compte du serveur, où sont ses images.
|
|
41
|
+
*/
|
|
42
|
+
export declare function packagesServer(input: Pick<RepairInput, "cwd" | "scope" | "managers" | "containers">, cache: string): {
|
|
43
|
+
command: string;
|
|
44
|
+
args: string[];
|
|
45
|
+
env: {
|
|
46
|
+
[k: string]: string;
|
|
47
|
+
};
|
|
48
|
+
};
|
|
35
49
|
export interface RepairInput {
|
|
36
50
|
repoId: string;
|
|
37
51
|
branch: string;
|
package/dist/src/core/repair.js
CHANGED
|
@@ -4,6 +4,7 @@ import { fileURLToPath } from "url";
|
|
|
4
4
|
import { z } from "zod";
|
|
5
5
|
import { RepairReportSchema, TEST_OUTCOMES } from "../../shared/schemas/model.schema.js";
|
|
6
6
|
import { runClaudeSession } from "./claude.js";
|
|
7
|
+
import { inheritedEnv } from "./commands.js";
|
|
7
8
|
import { TrackerError } from "./errors.js";
|
|
8
9
|
import { CACHE_DIR } from "./containers.js";
|
|
9
10
|
import { managerOf } from "./managers/index.js";
|
|
@@ -52,12 +53,19 @@ export function organizerServer(connection) {
|
|
|
52
53
|
const launch = process.platform === "win32" ? { command: "cmd", args: ["/c", "npx", "-y", ORGANIZER_PACKAGE] } : { command: "npx", args: ["-y", ORGANIZER_PACKAGE] };
|
|
53
54
|
return { ...launch, env: { ORGANIZER_URL: connection.url, ORGANIZER_TOKEN: connection.token } };
|
|
54
55
|
}
|
|
55
|
-
/**
|
|
56
|
-
|
|
56
|
+
/**
|
|
57
|
+
* Lancement du serveur `package-tools` du tracker sur le clone et le cache de
|
|
58
|
+
* l'opération, avec les outils de ses gestionnaires. Il reçoit les variables
|
|
59
|
+
* système du serveur (`HOME`, `XDG_RUNTIME_DIR`…), qui remplacent celles de
|
|
60
|
+
* Claude Code : Podman rootless y trouve le stockage et le dossier
|
|
61
|
+
* d'exécution du compte du serveur, où sont ses images.
|
|
62
|
+
*/
|
|
63
|
+
export function packagesServer(input, cache) {
|
|
57
64
|
const entry = fileURLToPath(new URL("../package-tools.js", import.meta.url));
|
|
58
65
|
return {
|
|
59
66
|
command: process.execPath,
|
|
60
67
|
args: [entry, "--root", input.cwd, "--cache", cache, "--scope", input.scope, "--managers", input.managers.join(","), "--runtime", JSON.stringify(input.containers.command)],
|
|
68
|
+
env: Object.fromEntries(Object.entries(inheritedEnv()).filter((entry) => entry[1] !== undefined)),
|
|
61
69
|
};
|
|
62
70
|
}
|
|
63
71
|
/** Résultat demandé à Claude avec l'organizer : le rapport et la clé de la tâche. */
|
|
@@ -0,0 +1,48 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Fichiers et calculs de la commande `setup` : unité systemd, site nginx,
|
|
3
|
+
* fichier `.env` et plage de sous-identifiants du compte de service.
|
|
4
|
+
*/
|
|
5
|
+
/** Nom du service systemd et du site nginx. */
|
|
6
|
+
export declare const SERVICE_NAME = "dependabot-tracker";
|
|
7
|
+
/** Taille d'une plage de sous-identifiants : un espace d'utilisateurs complet. */
|
|
8
|
+
export declare const SUBID_COUNT = 65536;
|
|
9
|
+
/** Ce que l'unité systemd et le site nginx décrivent. */
|
|
10
|
+
export interface ServiceLayout {
|
|
11
|
+
serviceUser: string;
|
|
12
|
+
serviceGroup: string;
|
|
13
|
+
uid: number;
|
|
14
|
+
/** Dossier personnel du compte : stockage de Podman et configuration de Claude Code. */
|
|
15
|
+
home: string;
|
|
16
|
+
dataDir: string;
|
|
17
|
+
/** Racine du paquet, qui porte `dist/` et le `.env`. */
|
|
18
|
+
packageRoot: string;
|
|
19
|
+
nodePath: string;
|
|
20
|
+
port: number;
|
|
21
|
+
}
|
|
22
|
+
/**
|
|
23
|
+
* Unité systemd du serveur. Le durcissement garde ce dont Podman rootless a
|
|
24
|
+
* besoin : `newuidmap` et `newgidmap` sont setuid (pas de `NoNewPrivileges`),
|
|
25
|
+
* la copie d'une image aux identifiants décalés remet les bits setuid et
|
|
26
|
+
* setgid de ses fichiers (pas de `RestrictSUIDSGID`), et le dossier
|
|
27
|
+
* d'exécution de l'utilisateur reste inscriptible ; bubblewrap, le bac à sable
|
|
28
|
+
* de Claude Code, exclut aussi `RestrictNamespaces`, `PrivateUsers` et
|
|
29
|
+
* `SystemCallFilter`.
|
|
30
|
+
*/
|
|
31
|
+
export declare function renderSystemdUnit(layout: ServiceLayout): string;
|
|
32
|
+
/** Site nginx en http vers le serveur ; certbot y ajoute ensuite le https. */
|
|
33
|
+
export declare function renderNginxSite(hostname: string, port: number): string;
|
|
34
|
+
/** Plage de sous-identifiants : premier identifiant et nombre. */
|
|
35
|
+
export interface SubIdRange {
|
|
36
|
+
start: number;
|
|
37
|
+
count: number;
|
|
38
|
+
}
|
|
39
|
+
/** Plages déclarées pour `user` dans le contenu d'un `/etc/subuid` ou `/etc/subgid`. */
|
|
40
|
+
export declare function subIdRangesOf(text: string, user: string): SubIdRange[];
|
|
41
|
+
/** Première plage libre de `SUBID_COUNT` identifiants, au-delà de toutes celles de `/etc/subuid` et `/etc/subgid`. */
|
|
42
|
+
export declare function nextFreeSubIdRange(subuid: string, subgid: string): SubIdRange;
|
|
43
|
+
/**
|
|
44
|
+
* Contenu du `.env` : les lignes existantes sont gardées, celles des
|
|
45
|
+
* variables de `values` remplacées sur place, les variables absentes ajoutées
|
|
46
|
+
* à la fin.
|
|
47
|
+
*/
|
|
48
|
+
export declare function mergeEnvFile(existing: string | undefined, values: Record<string, string>): string;
|
|
@@ -0,0 +1,147 @@
|
|
|
1
|
+
import path from "path";
|
|
2
|
+
/**
|
|
3
|
+
* Fichiers et calculs de la commande `setup` : unité systemd, site nginx,
|
|
4
|
+
* fichier `.env` et plage de sous-identifiants du compte de service.
|
|
5
|
+
*/
|
|
6
|
+
/** Nom du service systemd et du site nginx. */
|
|
7
|
+
export const SERVICE_NAME = "dependabot-tracker";
|
|
8
|
+
/** Taille d'une plage de sous-identifiants : un espace d'utilisateurs complet. */
|
|
9
|
+
export const SUBID_COUNT = 65536;
|
|
10
|
+
/** Premier sous-identifiant attribué quand aucune plage n'existe. */
|
|
11
|
+
const SUBID_FIRST = 100000;
|
|
12
|
+
/** Vrai si `child` est `parent` ou un dossier sous lui. */
|
|
13
|
+
function isInside(child, parent) {
|
|
14
|
+
const relative = path.relative(parent, child);
|
|
15
|
+
return !relative.startsWith("..") && !path.isAbsolute(relative);
|
|
16
|
+
}
|
|
17
|
+
/**
|
|
18
|
+
* Unité systemd du serveur. Le durcissement garde ce dont Podman rootless a
|
|
19
|
+
* besoin : `newuidmap` et `newgidmap` sont setuid (pas de `NoNewPrivileges`),
|
|
20
|
+
* la copie d'une image aux identifiants décalés remet les bits setuid et
|
|
21
|
+
* setgid de ses fichiers (pas de `RestrictSUIDSGID`), et le dossier
|
|
22
|
+
* d'exécution de l'utilisateur reste inscriptible ; bubblewrap, le bac à sable
|
|
23
|
+
* de Claude Code, exclut aussi `RestrictNamespaces`, `PrivateUsers` et
|
|
24
|
+
* `SystemCallFilter`.
|
|
25
|
+
*/
|
|
26
|
+
export function renderSystemdUnit(layout) {
|
|
27
|
+
const runtimeDir = `/run/user/${layout.uid}`;
|
|
28
|
+
const writable = [layout.home, ...(isInside(layout.dataDir, layout.home) ? [] : [layout.dataDir]), runtimeDir];
|
|
29
|
+
return [
|
|
30
|
+
`# Dependabot Tracker : interface, API et opérations, sur 127.0.0.1:${layout.port}.`,
|
|
31
|
+
`# Écrit par « mcp-dependabot-tracker setup », qui le réécrit à chaque passage.`,
|
|
32
|
+
"",
|
|
33
|
+
"[Unit]",
|
|
34
|
+
"Description=Dependabot Tracker (interface, API, opérations)",
|
|
35
|
+
"After=network-online.target",
|
|
36
|
+
"Wants=network-online.target",
|
|
37
|
+
"",
|
|
38
|
+
"[Service]",
|
|
39
|
+
"Type=simple",
|
|
40
|
+
`User=${layout.serviceUser}`,
|
|
41
|
+
`Group=${layout.serviceGroup}`,
|
|
42
|
+
`WorkingDirectory=${layout.packageRoot}`,
|
|
43
|
+
"Environment=NODE_ENV=production",
|
|
44
|
+
`Environment=XDG_RUNTIME_DIR=${runtimeDir}`,
|
|
45
|
+
`ExecStart=${layout.nodePath} ${layout.packageRoot}/dist/src/index.js serve`,
|
|
46
|
+
"Restart=on-failure",
|
|
47
|
+
"RestartSec=5",
|
|
48
|
+
"TimeoutStopSec=30",
|
|
49
|
+
"UMask=0077",
|
|
50
|
+
"",
|
|
51
|
+
"# Podman rootless : newuidmap et newgidmap sont setuid, et la copie des images",
|
|
52
|
+
"# aux identifiants décalés remet les bits setuid et setgid de leurs fichiers.",
|
|
53
|
+
"NoNewPrivileges=false",
|
|
54
|
+
"RestrictSUIDSGID=false",
|
|
55
|
+
"# bubblewrap, le bac à sable de Claude Code : ni RestrictNamespaces, ni PrivateUsers, ni SystemCallFilter.",
|
|
56
|
+
"PrivateTmp=true",
|
|
57
|
+
"ProtectSystem=strict",
|
|
58
|
+
"ProtectHome=read-only",
|
|
59
|
+
`ReadWritePaths=${writable.join(" ")}`,
|
|
60
|
+
"RestrictRealtime=true",
|
|
61
|
+
"LockPersonality=true",
|
|
62
|
+
"",
|
|
63
|
+
"StandardOutput=journal",
|
|
64
|
+
"StandardError=journal",
|
|
65
|
+
`SyslogIdentifier=${SERVICE_NAME}`,
|
|
66
|
+
"",
|
|
67
|
+
"[Install]",
|
|
68
|
+
"WantedBy=multi-user.target",
|
|
69
|
+
"",
|
|
70
|
+
].join("\n");
|
|
71
|
+
}
|
|
72
|
+
/** Site nginx en http vers le serveur ; certbot y ajoute ensuite le https. */
|
|
73
|
+
export function renderNginxSite(hostname, port) {
|
|
74
|
+
return [
|
|
75
|
+
`# Dependabot Tracker : ${hostname} vers 127.0.0.1:${port}.`,
|
|
76
|
+
"# Écrit par « mcp-dependabot-tracker setup » ; certbot y ajoute le certificat.",
|
|
77
|
+
"server {",
|
|
78
|
+
" listen 80;",
|
|
79
|
+
" listen [::]:80;",
|
|
80
|
+
` server_name ${hostname};`,
|
|
81
|
+
"",
|
|
82
|
+
" client_max_body_size 10m;",
|
|
83
|
+
"",
|
|
84
|
+
" location / {",
|
|
85
|
+
` proxy_pass http://127.0.0.1:${port};`,
|
|
86
|
+
" proxy_http_version 1.1;",
|
|
87
|
+
" proxy_set_header Host $host;",
|
|
88
|
+
" proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;",
|
|
89
|
+
" proxy_set_header X-Forwarded-Proto $scheme;",
|
|
90
|
+
" proxy_read_timeout 300s;",
|
|
91
|
+
" }",
|
|
92
|
+
"}",
|
|
93
|
+
"",
|
|
94
|
+
].join("\n");
|
|
95
|
+
}
|
|
96
|
+
/** Plages déclarées pour `user` dans le contenu d'un `/etc/subuid` ou `/etc/subgid`. */
|
|
97
|
+
export function subIdRangesOf(text, user) {
|
|
98
|
+
return parseSubIds(text)
|
|
99
|
+
.filter((entry) => entry.owner === user)
|
|
100
|
+
.map(({ start, count }) => ({ start, count }));
|
|
101
|
+
}
|
|
102
|
+
function parseSubIds(text) {
|
|
103
|
+
return text
|
|
104
|
+
.split(/\r?\n/)
|
|
105
|
+
.map((line) => line.trim())
|
|
106
|
+
.filter((line) => line !== "" && !line.startsWith("#"))
|
|
107
|
+
.map((line) => {
|
|
108
|
+
const [owner, start, count] = line.split(":");
|
|
109
|
+
return { owner, start: Number(start), count: Number(count) };
|
|
110
|
+
})
|
|
111
|
+
.filter((entry) => Number.isInteger(entry.start) && Number.isInteger(entry.count));
|
|
112
|
+
}
|
|
113
|
+
/** Première plage libre de `SUBID_COUNT` identifiants, au-delà de toutes celles de `/etc/subuid` et `/etc/subgid`. */
|
|
114
|
+
export function nextFreeSubIdRange(subuid, subgid) {
|
|
115
|
+
const end = [...parseSubIds(subuid), ...parseSubIds(subgid)].reduce((max, entry) => Math.max(max, entry.start + entry.count), SUBID_FIRST);
|
|
116
|
+
return { start: end, count: SUBID_COUNT };
|
|
117
|
+
}
|
|
118
|
+
/** Valeur d'une variable du `.env`, entre guillemets simples (lus tels quels par dotenv) quand elle en a besoin. */
|
|
119
|
+
function envValue(value) {
|
|
120
|
+
if (/^[A-Za-z0-9_./:@+=,-]*$/.test(value))
|
|
121
|
+
return value;
|
|
122
|
+
if (value.includes("'") || /[\r\n]/.test(value))
|
|
123
|
+
throw new Error(`The value ${JSON.stringify(value)} cannot be written to the .env file: it holds a quote or a line break.`);
|
|
124
|
+
return `'${value}'`;
|
|
125
|
+
}
|
|
126
|
+
/**
|
|
127
|
+
* Contenu du `.env` : les lignes existantes sont gardées, celles des
|
|
128
|
+
* variables de `values` remplacées sur place, les variables absentes ajoutées
|
|
129
|
+
* à la fin.
|
|
130
|
+
*/
|
|
131
|
+
export function mergeEnvFile(existing, values) {
|
|
132
|
+
const pending = new Map(Object.entries(values));
|
|
133
|
+
const lines = (existing ?? "").split(/\r?\n/);
|
|
134
|
+
if (lines.at(-1) === "")
|
|
135
|
+
lines.pop();
|
|
136
|
+
const merged = lines.map((line) => {
|
|
137
|
+
const key = /^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=/.exec(line)?.[1];
|
|
138
|
+
if (key === undefined || !pending.has(key))
|
|
139
|
+
return line;
|
|
140
|
+
const value = pending.get(key);
|
|
141
|
+
pending.delete(key);
|
|
142
|
+
return `${key}=${envValue(value)}`;
|
|
143
|
+
});
|
|
144
|
+
for (const [key, value] of pending)
|
|
145
|
+
merged.push(`${key}=${envValue(value)}`);
|
|
146
|
+
return `${merged.join("\n")}\n`;
|
|
147
|
+
}
|
package/dist/src/index.d.ts
CHANGED
|
@@ -1,6 +1,7 @@
|
|
|
1
1
|
#!/usr/bin/env node
|
|
2
2
|
/**
|
|
3
3
|
* Point d'entrée du paquet :
|
|
4
|
+
* setup installe le serveur sur cette machine (Linux, systemd, en root) ;
|
|
4
5
|
* serve le serveur Dependabot Tracker (interface, API, opérations) ;
|
|
5
6
|
* mcp le mode MCP, lancé par un agent, qui pilote un serveur ;
|
|
6
7
|
* user add|password|totp|remove|list gère les comptes de l'interface ;
|
package/dist/src/index.js
CHANGED
|
@@ -1,6 +1,7 @@
|
|
|
1
1
|
#!/usr/bin/env node
|
|
2
2
|
/**
|
|
3
3
|
* Point d'entrée du paquet :
|
|
4
|
+
* setup installe le serveur sur cette machine (Linux, systemd, en root) ;
|
|
4
5
|
* serve le serveur Dependabot Tracker (interface, API, opérations) ;
|
|
5
6
|
* mcp le mode MCP, lancé par un agent, qui pilote un serveur ;
|
|
6
7
|
* user add|password|totp|remove|list gère les comptes de l'interface ;
|
|
@@ -11,6 +12,7 @@
|
|
|
11
12
|
const { USERS_USAGE } = await import("./cli/users.js");
|
|
12
13
|
const USAGE = [
|
|
13
14
|
"Usage :",
|
|
15
|
+
" mcp-dependabot-tracker setup [options] installe le serveur sur cette machine (Linux, systemd, en root ; --help)",
|
|
14
16
|
" mcp-dependabot-tracker serve lance le serveur",
|
|
15
17
|
" mcp-dependabot-tracker mcp mode MCP, lancé par un agent (SERVER_URL, AGENT_TOKEN)",
|
|
16
18
|
USERS_USAGE,
|
|
@@ -36,6 +38,16 @@ else if (argv.includes("--claude-setup-mcp")) {
|
|
|
36
38
|
}
|
|
37
39
|
process.exit(runSetupMcp({ cwd: process.cwd(), force: argv.includes("--force"), connection: parsed.connection }));
|
|
38
40
|
}
|
|
41
|
+
else if (argv[0] === "setup") {
|
|
42
|
+
const { SETUP_USAGE, realHost, runSetup } = await import("./cli/setup.js");
|
|
43
|
+
if (argv.includes("--help")) {
|
|
44
|
+
console.log(SETUP_USAGE);
|
|
45
|
+
}
|
|
46
|
+
else {
|
|
47
|
+
const { packageRoot } = await import("./server/serve.js");
|
|
48
|
+
process.exit(await runSetup(argv.slice(1), realHost(packageRoot())));
|
|
49
|
+
}
|
|
50
|
+
}
|
|
39
51
|
else if (argv[0] === "serve") {
|
|
40
52
|
const { serve } = await import("./server/serve.js");
|
|
41
53
|
await serve();
|
|
@@ -1,3 +1,5 @@
|
|
|
1
|
+
/** Racine du paquet : le premier dossier qui contient un package.json, en remontant depuis ce module. */
|
|
2
|
+
export declare function packageRoot(): string;
|
|
1
3
|
/** Charge le `.env` de la racine du paquet, s'il existe ; ses valeurs priment sur l'environnement. */
|
|
2
4
|
export declare function loadPackageEnv(): void;
|
|
3
5
|
/**
|
package/dist/src/server/serve.js
CHANGED
|
@@ -27,7 +27,7 @@ import { createApp } from "./app.js";
|
|
|
27
27
|
/** Intervalle de vérification des dépôts à relire. */
|
|
28
28
|
const SYNC_CHECK_MS = 60_000;
|
|
29
29
|
/** Racine du paquet : le premier dossier qui contient un package.json, en remontant depuis ce module. */
|
|
30
|
-
function packageRoot() {
|
|
30
|
+
export function packageRoot() {
|
|
31
31
|
let current = path.dirname(fileURLToPath(import.meta.url));
|
|
32
32
|
while (!fs.existsSync(path.join(current, "package.json"))) {
|
|
33
33
|
const parent = path.dirname(current);
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@imenam/mcp-dependabot-tracker",
|
|
3
|
-
"version": "1.0.
|
|
3
|
+
"version": "1.0.33",
|
|
4
4
|
"description": "Server and web GUI that track the Dependabot alerts of GitHub repositories and fix their vulnerable dependencies (npm, pnpm, Composer) in a temporary clone: audit, automatic fixes in rootless Podman containers, fixes by Claude, then a branch and a pull request. An MCP mode lets agents drive the server.",
|
|
5
5
|
"main": "dist/src/index.js",
|
|
6
6
|
"scripts": {
|