@imenam/mcp-dependabot-tracker 1.0.30 → 1.0.32

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 (48) hide show
  1. package/README.md +41 -28
  2. package/dist/shared/schemas/model.schema.d.ts +64 -8
  3. package/dist/shared/schemas/model.schema.js +23 -8
  4. package/dist/src/core/commands.d.ts +5 -7
  5. package/dist/src/core/commands.js +7 -11
  6. package/dist/src/core/containers.d.ts +82 -0
  7. package/dist/src/core/containers.js +144 -0
  8. package/dist/src/core/managers/composer.d.ts +15 -0
  9. package/dist/src/core/managers/composer.js +234 -0
  10. package/dist/src/core/managers/index.d.ts +14 -0
  11. package/dist/src/core/managers/index.js +46 -0
  12. package/dist/src/core/managers/npm.d.ts +25 -0
  13. package/dist/src/core/managers/npm.js +203 -0
  14. package/dist/src/core/managers/php-version.d.ts +18 -0
  15. package/dist/src/core/managers/php-version.js +113 -0
  16. package/dist/src/core/managers/pnpm.d.ts +28 -0
  17. package/dist/src/core/managers/pnpm.js +249 -0
  18. package/dist/src/core/managers/tool-args.d.ts +17 -0
  19. package/dist/src/core/managers/tool-args.js +26 -0
  20. package/dist/src/core/managers/types.d.ts +61 -0
  21. package/dist/src/core/managers/types.js +11 -0
  22. package/dist/src/core/operations.d.ts +8 -5
  23. package/dist/src/core/operations.js +106 -77
  24. package/dist/src/core/repair.d.ts +20 -13
  25. package/dist/src/core/repair.js +110 -84
  26. package/dist/src/core/repos.d.ts +1 -1
  27. package/dist/src/core/repos.js +1 -1
  28. package/dist/src/core/sandbox.d.ts +7 -0
  29. package/dist/src/core/sandbox.js +31 -0
  30. package/dist/src/core/settings.d.ts +1 -1
  31. package/dist/src/core/settings.js +2 -2
  32. package/dist/src/core/store.js +3 -0
  33. package/dist/src/mcp.js +6 -5
  34. package/dist/src/package-tools.d.ts +13 -0
  35. package/dist/src/package-tools.js +92 -0
  36. package/dist/src/server/serve.js +2 -0
  37. package/dist/src/tools/format.js +11 -11
  38. package/dist/src/tools/tools.js +4 -4
  39. package/gui/dist/assets/index-DrVmedqf.js +71 -0
  40. package/gui/dist/index.html +1 -1
  41. package/package.json +2 -2
  42. package/dist/src/core/npm-audit.d.ts +0 -26
  43. package/dist/src/core/npm-audit.js +0 -76
  44. package/dist/src/core/npm-sandbox.d.ts +0 -33
  45. package/dist/src/core/npm-sandbox.js +0 -159
  46. package/dist/src/npm-tools.d.ts +0 -10
  47. package/dist/src/npm-tools.js +0 -136
  48. package/gui/dist/assets/index-CAOy2g1q.js +0 -71
@@ -0,0 +1,82 @@
1
+ import { type CommandResult } from "./commands.js";
2
+ /**
3
+ * Conteneurs jetables des commandes des gestionnaires de paquets d'une
4
+ * opération. Chaque commande tourne dans un conteneur Podman rootless créé pour
5
+ * elle et supprimé à sa fin : le clone de l'opération est monté en écriture sur
6
+ * `/work`, son cache sur `/cache`, et rien d'autre de l'hôte n'est visible.
7
+ * Le conteneur n'a aucune capacité, ne peut pas gagner de privilèges, garde son
8
+ * système de fichiers en lecture seule hors de ces montages et d'un `/tmp`
9
+ * vide, et tourne sous l'identité du compte du serveur, si bien que les
10
+ * fichiers écrits dans le clone lui appartiennent. Il ne reçoit aucune variable
11
+ * du serveur hormis le proxy : ni token, ni secret.
12
+ */
13
+ /** Commande qui lance Podman : `["podman"]` pour le serveur. */
14
+ export interface ContainerRuntime {
15
+ command: string[];
16
+ }
17
+ export declare const PODMAN: ContainerRuntime;
18
+ /** Dossiers de l'hôte montés dans le conteneur. */
19
+ export interface Workspace {
20
+ /** Clone du dépôt. */
21
+ root: string;
22
+ /** Cache de l'opération (npm, pnpm, Composer), hors du clone. */
23
+ cache: string;
24
+ }
25
+ /** Cache d'une opération, dans son répertoire temporaire, à côté du clone. */
26
+ export declare const CACHE_DIR = "cache";
27
+ /** Point de montage du clone dans le conteneur. */
28
+ export declare const CLONE_MOUNT = "/work";
29
+ /** Point de montage du cache de l'opération dans le conteneur. */
30
+ export declare const CACHE_MOUNT = "/cache";
31
+ /** Commande à lancer dans un conteneur. */
32
+ export interface ContainerCommand {
33
+ image: string;
34
+ /** Dossier de travail, relatif au clone : `""` pour la racine. */
35
+ cwd: string;
36
+ command: string[];
37
+ env?: Record<string, string>;
38
+ }
39
+ export interface ContainerRunOptions {
40
+ signal?: AbortSignal;
41
+ timeoutMs?: number;
42
+ }
43
+ /** Chemin, dans le conteneur, d'un dossier du clone. */
44
+ export declare function containerPath(relative: string): string;
45
+ /**
46
+ * Dossier d'un projet du clone, d'après son chemin relatif (`""` pour la
47
+ * racine) ; lève une erreur hors du clone, dans `node_modules` ou `vendor`, ou
48
+ * sans le fichier `manifest`.
49
+ */
50
+ export declare function projectDir(workspace: Workspace, project: string, manifest: string): string;
51
+ /** Arguments de `podman run` pour la commande `spec`, dans un conteneur nommé `name`. */
52
+ export declare function runArgs(workspace: Workspace, name: string, spec: ContainerCommand): string[];
53
+ /**
54
+ * Lance `spec` dans un conteneur jetable et rend son code de sortie et ses
55
+ * sorties. Une annulation ou un dépassement de délai supprime le conteneur,
56
+ * qui survivrait sinon à l'arrêt du client `podman`.
57
+ */
58
+ export declare function runInContainer(runtime: ContainerRuntime, workspace: Workspace, spec: ContainerCommand, options?: ContainerRunOptions): Promise<CommandResult>;
59
+ /** Télécharge la dernière version de l'image `image`. */
60
+ export declare function pullImage(runtime: ContainerRuntime, image: string, cwd: string, signal?: AbortSignal): Promise<void>;
61
+ /** Identifiant de l'image locale `tag`, ou null quand Podman ne l'a pas. */
62
+ export declare function imageId(runtime: ContainerRuntime, tag: string, cwd: string): Promise<string | null>;
63
+ /**
64
+ * Supprime l'image `id`, avec ses images parentes que plus rien ne référence ;
65
+ * rend null, ou la raison du refus de Podman (image encore utilisée par un
66
+ * conteneur, par exemple).
67
+ */
68
+ export declare function removeImage(runtime: ContainerRuntime, id: string, cwd: string): Promise<string | null>;
69
+ /**
70
+ * Construit l'image `tag` à partir du Containerfile `containerfile`, dont les
71
+ * images de base sont mises à jour. Le Containerfile est écrit dans un dossier
72
+ * temporaire qui ne contient que lui et sert de contexte à la construction,
73
+ * supprimé ensuite : le client `podman` de Windows et de macOS transmet le
74
+ * contexte et le fichier à la machine virtuelle de Podman, pas l'entrée
75
+ * standard.
76
+ */
77
+ export declare function buildImage(runtime: ContainerRuntime, tag: string, containerfile: string, signal?: AbortSignal): Promise<void>;
78
+ /**
79
+ * Vérifie que Podman est installé et tourne en mode rootless ; lève une erreur
80
+ * qui dit quoi installer ou régler.
81
+ */
82
+ export declare function assertContainersAvailable(runtime: ContainerRuntime, cwd: string): Promise<void>;
@@ -0,0 +1,144 @@
1
+ import crypto from "crypto";
2
+ import fs from "fs";
3
+ import os from "os";
4
+ import path from "path";
5
+ import { runCommand, tail } from "./commands.js";
6
+ import { TrackerError } from "./errors.js";
7
+ export const PODMAN = { command: ["podman"] };
8
+ /** Cache d'une opération, dans son répertoire temporaire, à côté du clone. */
9
+ export const CACHE_DIR = "cache";
10
+ /** Point de montage du clone dans le conteneur. */
11
+ export const CLONE_MOUNT = "/work";
12
+ /** Point de montage du cache de l'opération dans le conteneur. */
13
+ export const CACHE_MOUNT = "/cache";
14
+ /** Variables de proxy du serveur transmises au conteneur. */
15
+ const PROXY_ENV = ["HTTP_PROXY", "HTTPS_PROXY", "NO_PROXY", "http_proxy", "https_proxy", "no_proxy"];
16
+ /** Durée maximale du téléchargement ou de la construction d'une image. */
17
+ const IMAGE_TIMEOUT_MS = 15 * 60_000;
18
+ /** Chemin, dans le conteneur, d'un dossier du clone. */
19
+ export function containerPath(relative) {
20
+ return path.posix.join(CLONE_MOUNT, relative.split(path.sep).join("/"));
21
+ }
22
+ /**
23
+ * Dossier d'un projet du clone, d'après son chemin relatif (`""` pour la
24
+ * racine) ; lève une erreur hors du clone, dans `node_modules` ou `vendor`, ou
25
+ * sans le fichier `manifest`.
26
+ */
27
+ export function projectDir(workspace, project, manifest) {
28
+ const dir = path.resolve(workspace.root, project);
29
+ const relative = path.relative(workspace.root, dir);
30
+ const parts = relative.split(path.sep);
31
+ if (relative.startsWith("..") || path.isAbsolute(relative) || parts.includes("node_modules") || parts.includes("vendor")) {
32
+ throw new TrackerError(`"${project}" is not a project folder of the repository.`);
33
+ }
34
+ if (!fs.existsSync(path.join(dir, manifest)))
35
+ throw new TrackerError(`"${project || "."}" has no ${manifest}.`);
36
+ return dir;
37
+ }
38
+ /** Arguments de `podman run` pour la commande `spec`, dans un conteneur nommé `name`. */
39
+ export function runArgs(workspace, name, spec) {
40
+ const proxy = Object.fromEntries(PROXY_ENV.filter((key) => process.env[key] !== undefined).map((key) => [key, process.env[key]]));
41
+ const env = { ...proxy, HOME: "/tmp", LANG: "C.UTF-8", CI: "true", ...spec.env };
42
+ return [
43
+ "run",
44
+ "--rm",
45
+ "--init",
46
+ "--name", name,
47
+ "--pull=never",
48
+ "--userns=keep-id",
49
+ "--cap-drop=all",
50
+ "--security-opt=no-new-privileges",
51
+ "--read-only",
52
+ "--tmpfs", "/tmp:rw,exec,mode=1777",
53
+ "--volume", `${workspace.root}:${CLONE_MOUNT}`,
54
+ "--volume", `${workspace.cache}:${CACHE_MOUNT}`,
55
+ "--workdir", containerPath(spec.cwd),
56
+ ...Object.entries(env).flatMap(([key, value]) => ["--env", `${key}=${value}`]),
57
+ spec.image,
58
+ ...spec.command,
59
+ ];
60
+ }
61
+ function podman(runtime, args, options) {
62
+ const [command, ...prefix] = runtime.command;
63
+ return runCommand(command, [...prefix, ...args], { cwd: options.cwd, signal: options.signal, timeoutMs: options.timeoutMs });
64
+ }
65
+ /** Supprime un conteneur, qu'il tourne encore ou non. */
66
+ async function removeContainer(runtime, name, cwd) {
67
+ await podman(runtime, ["rm", "--force", "--ignore", "--time", "0", name], { cwd }).catch(() => undefined);
68
+ }
69
+ /**
70
+ * Lance `spec` dans un conteneur jetable et rend son code de sortie et ses
71
+ * sorties. Une annulation ou un dépassement de délai supprime le conteneur,
72
+ * qui survivrait sinon à l'arrêt du client `podman`.
73
+ */
74
+ export async function runInContainer(runtime, workspace, spec, options = {}) {
75
+ fs.mkdirSync(workspace.cache, { recursive: true });
76
+ const name = `dependabot-tracker-${crypto.randomBytes(6).toString("hex")}`;
77
+ try {
78
+ return await podman(runtime, runArgs(workspace, name, spec), { cwd: workspace.root, signal: options.signal, timeoutMs: options.timeoutMs });
79
+ }
80
+ catch (err) {
81
+ await removeContainer(runtime, name, workspace.root);
82
+ throw err;
83
+ }
84
+ }
85
+ /** Télécharge la dernière version de l'image `image`. */
86
+ export async function pullImage(runtime, image, cwd, signal) {
87
+ const result = await podman(runtime, ["pull", "--quiet", image], { cwd, signal, timeoutMs: IMAGE_TIMEOUT_MS });
88
+ if (result.code !== 0)
89
+ throw new TrackerError(`podman pull ${image} failed: ${tail(result.stderr) || tail(result.stdout)}`);
90
+ }
91
+ /** Identifiant de l'image locale `tag`, ou null quand Podman ne l'a pas. */
92
+ export async function imageId(runtime, tag, cwd) {
93
+ const result = await podman(runtime, ["image", "inspect", "--format", "{{.Id}}", tag], { cwd, timeoutMs: 60_000 });
94
+ const id = result.stdout.trim();
95
+ return result.code === 0 && id !== "" ? id : null;
96
+ }
97
+ /**
98
+ * Supprime l'image `id`, avec ses images parentes que plus rien ne référence ;
99
+ * rend null, ou la raison du refus de Podman (image encore utilisée par un
100
+ * conteneur, par exemple).
101
+ */
102
+ export async function removeImage(runtime, id, cwd) {
103
+ const result = await podman(runtime, ["rmi", id], { cwd, timeoutMs: 60_000 });
104
+ return result.code === 0 ? null : tail(result.stderr) || tail(result.stdout) || `exit code ${result.code}`;
105
+ }
106
+ /**
107
+ * Construit l'image `tag` à partir du Containerfile `containerfile`, dont les
108
+ * images de base sont mises à jour. Le Containerfile est écrit dans un dossier
109
+ * temporaire qui ne contient que lui et sert de contexte à la construction,
110
+ * supprimé ensuite : le client `podman` de Windows et de macOS transmet le
111
+ * contexte et le fichier à la machine virtuelle de Podman, pas l'entrée
112
+ * standard.
113
+ */
114
+ export async function buildImage(runtime, tag, containerfile, signal) {
115
+ const context = fs.mkdtempSync(path.join(os.tmpdir(), "dependabot-tracker-build-"));
116
+ try {
117
+ const file = path.join(context, "Containerfile");
118
+ fs.writeFileSync(file, containerfile, "utf-8");
119
+ const result = await podman(runtime, ["build", "--pull=newer", "--quiet", "--tag", tag, "--file", file, context], { cwd: context, signal, timeoutMs: IMAGE_TIMEOUT_MS });
120
+ if (result.code !== 0)
121
+ throw new TrackerError(`podman build ${tag} failed: ${tail(result.stderr) || tail(result.stdout)}`);
122
+ }
123
+ finally {
124
+ fs.rmSync(context, { recursive: true, force: true });
125
+ }
126
+ }
127
+ /**
128
+ * Vérifie que Podman est installé et tourne en mode rootless ; lève une erreur
129
+ * qui dit quoi installer ou régler.
130
+ */
131
+ export async function assertContainersAvailable(runtime, cwd) {
132
+ let result;
133
+ try {
134
+ result = await podman(runtime, ["info", "--format", "{{.Host.Security.Rootless}}"], { cwd, timeoutMs: 60_000 });
135
+ }
136
+ catch (err) {
137
+ throw new TrackerError(`The package manager commands of an operation run in Podman containers, and Podman cannot be started: ${err?.message ?? err} Install it on the server: sudo apt-get install -y podman uidmap passt`);
138
+ }
139
+ if (result.code !== 0)
140
+ throw new TrackerError(`podman info failed: ${tail(result.stderr) || tail(result.stdout)}`);
141
+ if (result.stdout.trim() !== "true") {
142
+ throw new TrackerError("Podman runs rootful: the server must run under an unprivileged account, whose containers are rootless.");
143
+ }
144
+ }
@@ -0,0 +1,15 @@
1
+ import type { Vulnerability } from "../../../shared/schemas/model.schema.js";
2
+ import { type ImageSpec, type Lockfile, type PackageManager } from "./types.js";
3
+ /** Image des commandes Composer d'un projet en PHP `version`, construite par le tracker. */
4
+ export declare function composerImage(version: string): ImageSpec;
5
+ /**
6
+ * Vulnérabilités d'un rapport `composer audit --format=json`, une par paquet,
7
+ * avec la gravité la plus haute de ses avis. Composer ne dit pas quelle version
8
+ * corrige un avis : la correction est inconnue.
9
+ */
10
+ export declare function parseComposerAudit(report: any, project: string): Vulnerability[];
11
+ /** Avis d'un rapport `composer audit`, réduits à ce qui sert les corrections, avec la version installée d'après le lockfile. */
12
+ export declare function composerFacts(report: any, project: string, installed: Lockfile): unknown[];
13
+ /** Lit un `composer.lock` : version de chaque paquet de `packages` et de `packages-dev`. */
14
+ export declare function readComposerLock(text: string, project: string): Lockfile;
15
+ export declare const composer: PackageManager;
@@ -0,0 +1,234 @@
1
+ import fs from "fs";
2
+ import path from "path";
3
+ import { tail } from "../commands.js";
4
+ import { CACHE_MOUNT, projectDir } from "../containers.js";
5
+ import { TrackerError } from "../errors.js";
6
+ import { phpVersionFor } from "./php-version.js";
7
+ import { checkedName, nameArg, onlyFields } from "./tool-args.js";
8
+ import { projectLabel, runManager } from "./types.js";
9
+ /** Image des commandes Composer d'un projet en PHP `version`, construite par le tracker. */
10
+ export function composerImage(version) {
11
+ return {
12
+ name: `localhost/mcp-dependabot-tracker/composer:php${version}`,
13
+ containerfile: [
14
+ `FROM docker.io/library/php:${version}-cli`,
15
+ "COPY --from=docker.io/composer/composer:2-bin /composer /usr/bin/composer",
16
+ "RUN apt-get update && apt-get install -y --no-install-recommends git unzip && rm -rf /var/lib/apt/lists/*",
17
+ "",
18
+ ].join("\n"),
19
+ };
20
+ }
21
+ /**
22
+ * Variables des commandes Composer : dossiers et cache de l'opération, aucune
23
+ * question, et aucun blocage des versions vulnérables à la résolution, pour
24
+ * qu'une mise à jour ciblée aboutisse quand un autre paquet du lockfile reste
25
+ * vulnérable.
26
+ */
27
+ const COMPOSER_ENV = {
28
+ COMPOSER_HOME: `${CACHE_MOUNT}/composer`,
29
+ COMPOSER_CACHE_DIR: `${CACHE_MOUNT}/composer-cache`,
30
+ COMPOSER_NO_INTERACTION: "1",
31
+ COMPOSER_NO_BLOCKING: "1",
32
+ };
33
+ /** Options qui empêchent les scripts et les plugins Composer du projet de s'exécuter. */
34
+ const NO_CODE = ["--no-scripts", "--no-plugins"];
35
+ /**
36
+ * Mise à jour du lockfile seul : sans installation, sans scripts ni plugins,
37
+ * sans audit, et sans exiger les extensions PHP du projet, que l'image n'a pas
38
+ * forcément et qui ne changent pas la résolution.
39
+ */
40
+ const LOCK_ONLY_UPDATE = ["--with-all-dependencies", "--no-install", ...NO_CODE, "--no-audit", "--ignore-platform-req=ext-*"];
41
+ /** Code de sortie de Composer quand les dépendances ne peuvent pas être résolues. */
42
+ const UNRESOLVABLE = 2;
43
+ /** Avis gardés par paquet dans les faits transmis à Claude. */
44
+ const MAX_ADVISORIES = 5;
45
+ function readJson(file) {
46
+ try {
47
+ return JSON.parse(fs.readFileSync(file, "utf-8"));
48
+ }
49
+ catch (err) {
50
+ throw new TrackerError(`${path.basename(file)} cannot be read: ${err.message}`);
51
+ }
52
+ }
53
+ /** Version de PHP d'un projet du clone, d'après son composer.json. */
54
+ function phpVersion(dir) {
55
+ try {
56
+ return phpVersionFor(readJson(path.join(dir, "composer.json")));
57
+ }
58
+ catch (err) {
59
+ throw new TrackerError(err.message);
60
+ }
61
+ }
62
+ /** Gravité d'un avis Composer sur l'échelle de npm ; un avis sans gravité compte comme `info`. */
63
+ function severityOf(severity) {
64
+ if (severity === "critical" || severity === "high" || severity === "low")
65
+ return severity;
66
+ if (severity === "medium")
67
+ return "moderate";
68
+ return "info";
69
+ }
70
+ /** Avis d'un rapport `composer audit --format=json`, par paquet ; PHP sérialise une liste en tableau ou en objet. */
71
+ function advisoriesOf(report, project) {
72
+ if (!report || typeof report.advisories !== "object" || report.advisories === null) {
73
+ throw new TrackerError(`Unsupported composer audit report for ${projectLabel(project)}composer.lock: expected an "advisories" entry.`);
74
+ }
75
+ return Object.entries(report.advisories)
76
+ .map(([name, list]) => [name, Array.isArray(list) ? list : Object.values(list)])
77
+ .sort(([a], [b]) => a.localeCompare(b));
78
+ }
79
+ /**
80
+ * Vulnérabilités d'un rapport `composer audit --format=json`, une par paquet,
81
+ * avec la gravité la plus haute de ses avis. Composer ne dit pas quelle version
82
+ * corrige un avis : la correction est inconnue.
83
+ */
84
+ export function parseComposerAudit(report, project) {
85
+ const severities = ["critical", "high", "moderate", "low", "info"];
86
+ return advisoriesOf(report, project).map(([name, advisories]) => ({
87
+ project,
88
+ manager: "composer",
89
+ name,
90
+ severity: advisories.map((advisory) => severityOf(advisory.severity)).sort((a, b) => severities.indexOf(a) - severities.indexOf(b))[0] ?? "info",
91
+ fix: "unknown",
92
+ }));
93
+ }
94
+ /** Avis d'un rapport `composer audit`, réduits à ce qui sert les corrections, avec la version installée d'après le lockfile. */
95
+ export function composerFacts(report, project, installed) {
96
+ return advisoriesOf(report, project).map(([name, advisories]) => ({
97
+ manager: "composer",
98
+ project: project === "" ? "." : project,
99
+ name,
100
+ installed: installed[name] ?? null,
101
+ advisories: advisories.slice(0, MAX_ADVISORIES).map((advisory) => ({
102
+ title: advisory.title,
103
+ cve: advisory.cve ?? null,
104
+ link: advisory.link ?? null,
105
+ severity: advisory.severity ?? null,
106
+ affectedVersions: advisory.affectedVersions,
107
+ })),
108
+ }));
109
+ }
110
+ /** Lit un `composer.lock` : version de chaque paquet de `packages` et de `packages-dev`. */
111
+ export function readComposerLock(text, project) {
112
+ let json;
113
+ try {
114
+ json = JSON.parse(text);
115
+ }
116
+ catch (err) {
117
+ throw new TrackerError(`${projectLabel(project)}composer.lock is not valid JSON: ${err.message}`);
118
+ }
119
+ if (!json || !Array.isArray(json.packages))
120
+ throw new TrackerError(`${projectLabel(project)}composer.lock has no "packages" list.`);
121
+ const versions = {};
122
+ for (const entry of [...json.packages, ...(Array.isArray(json["packages-dev"]) ? json["packages-dev"] : [])]) {
123
+ if (typeof entry?.name === "string" && typeof entry?.version === "string")
124
+ versions[entry.name] = entry.version;
125
+ }
126
+ return versions;
127
+ }
128
+ /** Options Composer qui limitent l'audit au périmètre `scope`. */
129
+ function composerScopeArgs(scope) {
130
+ return scope === "production" ? ["--no-dev"] : [];
131
+ }
132
+ export const composer = {
133
+ id: "composer",
134
+ lockfile: "composer.lock",
135
+ manifest: "composer.json",
136
+ image: (ctx, project) => composerImage(phpVersion(projectDir(ctx.workspace, project, "composer.json"))),
137
+ command: (ctx, project, args) => {
138
+ const dir = projectDir(ctx.workspace, project, "composer.json");
139
+ return { image: composerImage(phpVersion(dir)).name, cwd: project, command: ["composer", ...args], env: COMPOSER_ENV };
140
+ },
141
+ audit: async (ctx, project) => {
142
+ const result = await runManager(composer, ctx, project, ["audit", "--locked", "--format=json", ...composerScopeArgs(ctx.scope), ...NO_CODE]);
143
+ let report;
144
+ try {
145
+ report = JSON.parse(result.stdout);
146
+ }
147
+ catch {
148
+ throw new TrackerError(`composer audit in ${projectLabel(project) || "./"} did not return JSON: ${tail(result.stderr) || tail(result.stdout) || "no output"}`);
149
+ }
150
+ const lock = readComposerLock(fs.readFileSync(path.join(ctx.workspace.root, project, "composer.lock"), "utf-8"), project);
151
+ return { vulnerabilities: parseComposerAudit(report, project), facts: composerFacts(report, project, lock) };
152
+ },
153
+ fix: async (ctx, project, vulnerabilities) => {
154
+ const packages = vulnerabilities.map((vulnerability) => checkedName(vulnerability.name, "package"));
155
+ const result = await runManager(composer, ctx, project, ["update", ...packages, ...LOCK_ONLY_UPDATE]);
156
+ if (result.code === UNRESOLVABLE) {
157
+ ctx.log(`Composer found no update of the vulnerable packages within the constraints of composer.json: ${tail(result.stderr, 6) || tail(result.stdout, 6)}`);
158
+ return;
159
+ }
160
+ if (result.code !== 0)
161
+ throw new TrackerError(`composer update failed in ${projectLabel(project) || "./"}: ${tail(result.stderr) || tail(result.stdout) || "no output"}`);
162
+ },
163
+ readLock: readComposerLock,
164
+ fixCommand: () => ["composer update <vulnerable packages>", ...LOCK_ONLY_UPDATE].join(" "),
165
+ tools: [
166
+ {
167
+ name: "composer_update_lock",
168
+ description: "Run composer update <packages> --with-all-dependencies --no-install --no-scripts --no-plugins --ignore-platform-req=ext-* in a Composer project: updates composer.lock for the packages given, within the constraints of composer.json, without installing vendor/. Use it after changing a constraint in composer.json.",
169
+ properties: { packages: { type: "array", items: { type: "string" }, description: "Packages to update, e.g. guzzlehttp/psr7." } },
170
+ required: ["packages"],
171
+ args: (args) => {
172
+ onlyFields(args, ["packages"]);
173
+ const packages = args?.packages;
174
+ if (!Array.isArray(packages) || packages.length === 0 || packages.some((item) => typeof item !== "string"))
175
+ throw new Error('"packages" must be a non-empty list of package names.');
176
+ return ["update", ...packages.map((item) => checkedName(item.trim(), "packages")), ...LOCK_ONLY_UPDATE];
177
+ },
178
+ },
179
+ {
180
+ name: "composer_audit",
181
+ description: "Run composer audit --locked in a Composer project, with the scope of the operation.",
182
+ properties: {},
183
+ required: [],
184
+ args: (args, scope) => {
185
+ onlyFields(args);
186
+ return ["audit", "--locked", ...composerScopeArgs(scope), ...NO_CODE];
187
+ },
188
+ },
189
+ {
190
+ name: "composer_install",
191
+ description: "Run composer install in a Composer project: installs vendor/ from composer.lock, scripts and plugins included. The image has the PHP version of the project but only the default extensions of the official PHP image.",
192
+ properties: {},
193
+ required: [],
194
+ args: (args) => {
195
+ onlyFields(args);
196
+ return ["install"];
197
+ },
198
+ },
199
+ {
200
+ name: "composer_test",
201
+ description: "Run the test script of composer.json in a Composer project (composer run-script test).",
202
+ properties: {},
203
+ required: [],
204
+ args: (args) => {
205
+ onlyFields(args);
206
+ return ["run-script", "test"];
207
+ },
208
+ },
209
+ {
210
+ name: "composer_run",
211
+ description: "Run a script of composer.json in a Composer project (composer run-script <script>).",
212
+ properties: { script: { type: "string", description: "Name of the script." } },
213
+ required: ["script"],
214
+ args: (args) => {
215
+ onlyFields(args, ["script"]);
216
+ return ["run-script", nameArg(args, "script")];
217
+ },
218
+ },
219
+ {
220
+ name: "composer_why",
221
+ description: "Show which packages depend on a package in a Composer project, as a tree (composer depends --locked --tree <package>).",
222
+ properties: { package: { type: "string", description: "Name of the package, e.g. guzzlehttp/psr7." } },
223
+ required: ["package"],
224
+ args: (args) => {
225
+ onlyFields(args, ["package"]);
226
+ return ["depends", "--locked", "--tree", nameArg(args, "package")];
227
+ },
228
+ },
229
+ ],
230
+ guide: (scope, server) => [
231
+ `- Composer projects (composer.lock): composer audit gives no fixed version, only the affected ranges: find the fixed version in the advisory. Widen the constraint of the package in composer.json with Edit when the fix needs it, then update the lockfile with the ${server} tool composer_update_lock.`,
232
+ ` Check with composer_audit${scope === "production" ? " (it runs `composer audit --no-dev`)" : ""}; composer_install to install the dependencies, then composer_test (or composer_run) when composer.json has a test script; composer_why when useful. A missing PHP extension in the container is not a failure of your fixes: say so in your report.`,
233
+ ].join("\n"),
234
+ };
@@ -0,0 +1,14 @@
1
+ import type { Change, ManagerId, Project } from "../../../shared/schemas/model.schema.js";
2
+ import type { Lockfile, PackageManager } from "./types.js";
3
+ /** Gestionnaires de paquets pris en charge, dans l'ordre où leurs projets sont traités. */
4
+ export declare const PACKAGE_MANAGERS: PackageManager[];
5
+ /** Gestionnaire d'identifiant `id`. */
6
+ export declare function managerOf(id: ManagerId): PackageManager;
7
+ /** Projets d'un dépôt d'après ses fichiers suivis : chaque dossier qui suit le lockfile d'un gestionnaire. */
8
+ export declare function detectProjects(files: string[]): Project[];
9
+ /** Dossiers de dépendances installées d'un projet, relatifs à la racine du clone : jamais commités. */
10
+ export declare function installedDirs(project: Project): string[];
11
+ /** Lockfile d'un projet, relatif à la racine du clone. */
12
+ export declare function lockfilePath(project: Project): string;
13
+ /** Paquets dont la version diffère entre deux lockfiles d'un projet ; `from` null pour un ajout, `to` null pour un retrait. */
14
+ export declare function diffLockfiles(before: Lockfile, after: Lockfile, project: Project): Change[];
@@ -0,0 +1,46 @@
1
+ import path from "path";
2
+ import { composer } from "./composer.js";
3
+ import { npm } from "./npm.js";
4
+ import { pnpm } from "./pnpm.js";
5
+ /** Gestionnaires de paquets pris en charge, dans l'ordre où leurs projets sont traités. */
6
+ export const PACKAGE_MANAGERS = [npm, pnpm, composer];
7
+ /** Gestionnaire d'identifiant `id`. */
8
+ export function managerOf(id) {
9
+ const manager = PACKAGE_MANAGERS.find((candidate) => candidate.id === id);
10
+ if (!manager)
11
+ throw new Error(`Unknown package manager: ${id}`);
12
+ return manager;
13
+ }
14
+ /** Projets d'un dépôt d'après ses fichiers suivis : chaque dossier qui suit le lockfile d'un gestionnaire. */
15
+ export function detectProjects(files) {
16
+ const projects = [];
17
+ for (const manager of PACKAGE_MANAGERS) {
18
+ for (const file of files) {
19
+ if (path.posix.basename(file) !== manager.lockfile)
20
+ continue;
21
+ const dir = path.posix.dirname(file);
22
+ projects.push({ path: dir === "." ? "" : dir, manager: manager.id });
23
+ }
24
+ }
25
+ return projects.sort((a, b) => a.path.localeCompare(b.path) || PACKAGE_MANAGERS.indexOf(managerOf(a.manager)) - PACKAGE_MANAGERS.indexOf(managerOf(b.manager)));
26
+ }
27
+ /** Dossiers de dépendances installées d'un projet, relatifs à la racine du clone : jamais commités. */
28
+ export function installedDirs(project) {
29
+ return project.manager === "composer" ? [path.posix.join(project.path, "vendor")] : [];
30
+ }
31
+ /** Lockfile d'un projet, relatif à la racine du clone. */
32
+ export function lockfilePath(project) {
33
+ return path.posix.join(project.path, managerOf(project.manager).lockfile);
34
+ }
35
+ /** Paquets dont la version diffère entre deux lockfiles d'un projet ; `from` null pour un ajout, `to` null pour un retrait. */
36
+ export function diffLockfiles(before, after, project) {
37
+ const names = new Set([...Object.keys(before), ...Object.keys(after)]);
38
+ const changes = [];
39
+ for (const name of names) {
40
+ const from = before[name] ?? null;
41
+ const to = after[name] ?? null;
42
+ if (from !== to)
43
+ changes.push({ project: project.path, manager: project.manager, name, from, to });
44
+ }
45
+ return changes.sort((a, b) => a.name.localeCompare(b.name));
46
+ }
@@ -0,0 +1,25 @@
1
+ import { type AuditScope, type Vulnerability } from "../../../shared/schemas/model.schema.js";
2
+ import { type Lockfile, type PackageManager } from "./types.js";
3
+ /** Image des commandes npm : Node.js LTS, npm compris. */
4
+ export declare const NODE_IMAGE = "docker.io/library/node:26-slim";
5
+ /** Options npm qui limitent l'audit et ses corrections au périmètre `scope`. */
6
+ export declare function npmScopeArgs(scope: AuditScope): string[];
7
+ /** Lit la sortie JSON d'un appel npm ; une sortie qui n'est pas du JSON, ou qui porte une erreur npm, lève une erreur. */
8
+ export declare function parseNpmJson(stdout: string, stderr: string, what: string): any;
9
+ /**
10
+ * Vulnérabilités d'un rapport `npm audit --json` (format `auditReportVersion` 2).
11
+ * `fixAvailable` vaut false (aucune correction), true (dans les plages déclarées)
12
+ * ou un objet `{ name, version, isSemVerMajor }` qui désigne le paquet à mettre à
13
+ * jour, éventuellement d'une version majeure.
14
+ */
15
+ export declare function parseAuditReport(report: any, project: string): Vulnerability[];
16
+ /** Vulnérabilités d'un rapport `npm audit --json`, réduites à ce qui sert les corrections. */
17
+ export declare function auditFacts(report: any, project: string): unknown[];
18
+ /**
19
+ * Lit un `package-lock.json` : version de chaque paquet installé, par chemin
20
+ * d'installation sans le premier `node_modules/` (`lodash`, ou
21
+ * `d3-sankey/node_modules/d3-array` pour une copie imbriquée). Un lockfile v1
22
+ * (npm 6), sans `packages`, est refusé.
23
+ */
24
+ export declare function readPackageLock(text: string, project: string): Lockfile;
25
+ export declare const npm: PackageManager;