@4da/mcp-server 5.0.4 → 6.0.0

package/dist/live/install-state.js

@@ -0,0 +1,150 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Install drift: what node_modules holds versus what the lockfile pins.
+ *
+ * Measured 2026-09-10: mcp-4da-server/pnpm-lock.yaml pinned hono 4.13.5 (PR
+ * #632, the fix for CVE-2026-84363/-84364/-84365) while
+ * mcp-4da-server/node_modules/hono held 4.13.1 for 25 days, because
+ * activation ran `pnpm install` only at the repo root. Every 4DA surface
+ * reported hono fixed, because every surface read the lockfile. A lockfile
+ * says what SHOULD be installed; only node_modules says what IS, and the
+ * installed copy is the one that runs.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileSignature } from "./file-signature.js";
+/** Parent directories the lookup may climb for hoisted workspaces. */
+const MAX_PARENT_LEVELS = 6;
+/**
+ * Files an install rewrites (pnpm, npm >= 7, yarn 1, yarn berry's
+ * node-modules linker). A change to one is how a reinstall that fixes drift,
+ * without touching the lockfile, gets noticed.
+ */
+const INSTALL_MARKERS = [".modules.yaml", ".package-lock.json", ".yarn-integrity", ".yarn-state.yml"];
+/** The reinstall command for the lockfile a directory resolved from, or null for a non-npm file. */
+export function installFixFor(lockfilePath) {
+    switch (path.basename(lockfilePath)) {
+        case "pnpm-lock.yaml":
+            return "pnpm install";
+        case "package-lock.json":
+            return "npm ci";
+        case "yarn.lock":
+            return "yarn install";
+        case "bun.lock":
+            return "bun install";
+        default:
+            return null;
+    }
+}
+function isDirectory(p) {
+    try {
+        return fs.statSync(p).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * The directories a lookup from `dir` visits, nearest first: `dir`, then its
+ * parents, stopping at the directory that holds `.git` (the repository root)
+ * or after MAX_PARENT_LEVELS parents.
+ */
+function lookupChain(dir) {
+    const chain = [];
+    let current = path.resolve(dir);
+    for (let level = 0; level <= MAX_PARENT_LEVELS; level++) {
+        chain.push(current);
+        if (fs.existsSync(path.join(current, ".git")))
+            break;
+        const parent = path.dirname(current);
+        if (parent === current)
+            break;
+        current = parent;
+    }
+    return chain;
+}
+/**
+ * `<d>/node_modules/<name>/package.json` for the nearest `d` in the lookup
+ * chain that has it (scoped names included), or null. This is the copy
+ * Node's resolver would load from `dir`.
+ */
+export function findInstalledManifest(dir, name, chain = lookupChain(dir)) {
+    for (const d of chain) {
+        const candidate = path.join(d, "node_modules", ...name.split("/"), "package.json");
+        if (fs.existsSync(candidate))
+            return candidate;
+    }
+    return null;
+}
+function readManifestVersion(manifest) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(manifest, "utf-8"));
+        const version = typeof parsed.version === "string" ? parsed.version.trim() : "";
+        return version || null;
+    }
+    catch {
+        return null;
+    }
+}
+/** The installed version of `name` as seen from `dir`, or null when not installed or unreadable. Never throws. */
+export function readInstalledVersion(dir, name) {
+    const manifest = findInstalledManifest(dir, name);
+    return manifest ? readManifestVersion(manifest) : null;
+}
+/**
+ * Compare each npm direct dependency's lockfile version with node_modules.
+ *
+ * Skipped entirely when `dir` has no node_modules of its own: a checkout that
+ * was never installed has no installed copy to disagree with the lockfile,
+ * and borrowing a parent project's node_modules would compare against a
+ * different project's install. The node_modules path is still tracked, so an
+ * install that creates it is noticed.
+ */
+export function checkInstallState(dir, resolved, lockfilePath) {
+    const nodeModules = path.join(dir, "node_modules");
+    const signatures = new Map([[nodeModules, fileSignature(nodeModules)]]);
+    const fix = installFixFor(lockfilePath);
+    if (!fix || !isDirectory(nodeModules)) {
+        return { resolved, drift: [], driftAuditDeps: [], signatures };
+    }
+    const chain = lookupChain(dir);
+    for (const d of chain) {
+        const nm = path.join(d, "node_modules");
+        if (!isDirectory(nm))
+            continue;
+        signatures.set(nm, fileSignature(nm));
+        for (const marker of INSTALL_MARKERS) {
+            const markerPath = path.join(nm, marker);
+            signatures.set(markerPath, fileSignature(markerPath));
+        }
+    }
+    const drift = [];
+    const driftAuditDeps = [];
+    const checked = resolved.map((dep) => {
+        if (!dep.isDirect || dep.ecosystem !== "npm" || !dep.version)
+            return dep;
+        const manifest = findInstalledManifest(dir, dep.name, chain);
+        if (manifest)
+            signatures.set(manifest, fileSignature(manifest));
+        const installedVersion = manifest ? readManifestVersion(manifest) : null;
+        if (installedVersion && installedVersion !== dep.version) {
+            drift.push({
+                package: dep.name,
+                dir,
+                lockfileVersion: dep.version,
+                installedVersion,
+                fix,
+                isDev: dep.isDev,
+            });
+            driftAuditDeps.push({
+                ...dep,
+                version: installedVersion,
+                installedVersion,
+                installDriftOf: dep.version,
+                installFix: fix,
+            });
+        }
+        return { ...dep, installedVersion };
+    });
+    return { resolved: checked, drift, driftAuditDeps, signatures };
+}

package/dist/live/js-lockfile-readers.d.ts

@@ -0,0 +1,46 @@
+/**
+ * pnpm and yarn lockfile readers: exact versions, no YAML parser.
+ *
+ * Measured 2026-09-11: the previous pnpm reader matched package keys with
+ * `/^\s{2}'?(.+?)@(\d…)/gm` over the whole file. `\s` also matches a newline,
+ * and pnpm writes a blank line between entries, so each match began on the
+ * blank line and kept the next key's opening quote. Every scoped package
+ * outside the importer blocks reached OSV as `'@scope/name` and matched
+ * nothing: 525 names across five lockfiles in this repository, including
+ * `@humanfs/node@0.16.7` (GHSA-p498-v437-472g), which GitHub and the app both
+ * flagged. The test fixture had no blank lines, so it passed. The yarn reader's
+ * header pattern could not start with `@`, so it dropped every scoped package,
+ * and it never read yarn berry's `version: x` lines.
+ *
+ * So indentation is read by column on whole lines, never with `\s` across a
+ * line break, and a key that does not pin a registry version (git, tarball,
+ * file, link) is dropped instead of being queried as a package name.
+ */
+import type { InstanceSet } from "./lockfile-types.js";
+/**
+ * Splits one `packages:` or `snapshots:` key into [name, version]:
+ * v9 `'@scope/pkg@1.2.3(peer@4.5.6)'`, v6 `/pkg@1.2.3`, v5 `/@scope/pkg/1.2.3_peer@4.5.6`.
+ * Returns null for a key that does not pin a registry version.
+ */
+export declare function parsePnpmKey(rawKey: string): [string, string] | null;
+/**
+ * Reads a pnpm lockfile (v5.x, v6 or v9) into `versions`; the first version seen wins.
+ *
+ * Direct pins are read first, from the dependency blocks: `importers:` → `  <dir>:` →
+ * `    dependencies:` in a workspace, or a top-level `dependencies:` block in a v5/v6
+ * single-project file. A direct pin therefore wins over a transitive copy of the same
+ * name. Every other package comes from a key exactly two columns deep under
+ * `packages:` or `snapshots:`.
+ *
+ * `instances`, when given, receives EVERY copy (a package keyed at two versions is
+ * two copies), with the `dev: true|false` that v5/v6 lockfiles write under each
+ * package key. pnpm 9 dropped that field, so its copies have unknown scope.
+ */
+export declare function readPnpmLock(content: string, versions: Map<string, string>, instances?: InstanceSet): void;
+/**
+ * Reads a yarn lockfile (v1 or berry) into `versions`.
+ * v1: `"@scope/pkg@^1.0.0", "@scope/pkg@^1.1.0":` then `  version "1.2.3"`.
+ * berry: `"@scope/pkg@npm:^1.0.0":` then `  version: 1.2.3`.
+ * Workspace, link, portal, file, exec and patch entries do not name a registry version.
+ */
+export declare function readYarnLock(content: string, versions: Map<string, string>, instances?: InstanceSet, specs?: Map<string, string>): void;

package/dist/live/js-lockfile-readers.js

@@ -0,0 +1,181 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * pnpm and yarn lockfile readers: exact versions, no YAML parser.
+ *
+ * Measured 2026-09-11: the previous pnpm reader matched package keys with
+ * `/^\s{2}'?(.+?)@(\d…)/gm` over the whole file. `\s` also matches a newline,
+ * and pnpm writes a blank line between entries, so each match began on the
+ * blank line and kept the next key's opening quote. Every scoped package
+ * outside the importer blocks reached OSV as `'@scope/name` and matched
+ * nothing: 525 names across five lockfiles in this repository, including
+ * `@humanfs/node@0.16.7` (GHSA-p498-v437-472g), which GitHub and the app both
+ * flagged. The test fixture had no blank lines, so it passed. The yarn reader's
+ * header pattern could not start with `@`, so it dropped every scoped package,
+ * and it never read yarn berry's `version: x` lines.
+ *
+ * So indentation is read by column on whole lines, never with `\s` across a
+ * line break, and a key that does not pin a registry version (git, tarball,
+ * file, link) is dropped instead of being queried as a package name.
+ */
+const DEPENDENCY_BLOCKS = new Set(["dependencies:", "devDependencies:", "optionalDependencies:"]);
+/** A bare npm package name, scoped or not: no whitespace, no `/` beyond the scope, no version. */
+const PACKAGE_NAME = /^(?:@[^\s/@]+\/)?[^\s/@]+$/;
+function unquote(s) {
+    return s.length >= 2 && (s[0] === "'" || s[0] === '"') && s[s.length - 1] === s[0] ? s.slice(1, -1) : s;
+}
+/** An exact version with pnpm's peer suffixes removed: v6/v9 `1.2.3(react@18)`, v5 `1.2.3_react@18`. */
+function exactVersion(raw) {
+    const version = unquote(raw.trim()).split("(")[0].split("_")[0].trim();
+    return /^\d/.test(version) ? version : null;
+}
+/**
+ * Splits one `packages:` or `snapshots:` key into [name, version]:
+ * v9 `'@scope/pkg@1.2.3(peer@4.5.6)'`, v6 `/pkg@1.2.3`, v5 `/@scope/pkg/1.2.3_peer@4.5.6`.
+ * Returns null for a key that does not pin a registry version.
+ */
+export function parsePnpmKey(rawKey) {
+    let key = unquote(rawKey.trim());
+    if (key.startsWith("/"))
+        key = key.slice(1);
+    const peers = key.indexOf("(");
+    if (peers >= 0)
+        key = key.slice(0, peers);
+    // v6 and v9: the separator is the first `@` after a scoped name's own leading `@`.
+    const at = key.indexOf("@", key.startsWith("@") ? 1 : 0);
+    if (at > 0) {
+        const name = key.slice(0, at);
+        const version = exactVersion(key.slice(at + 1));
+        if (PACKAGE_NAME.test(name) && version)
+            return [name, version];
+    }
+    // v5: `name/version`, with any peers after an underscore.
+    const v5 = /^((?:@[^/@\s]+\/)?[^/@\s]+)\/(\d[^/]*)$/.exec(key);
+    if (v5) {
+        const version = exactVersion(v5[2]);
+        if (version)
+            return [v5[1], version];
+    }
+    return null;
+}
+/**
+ * Reads a pnpm lockfile (v5.x, v6 or v9) into `versions`; the first version seen wins.
+ *
+ * Direct pins are read first, from the dependency blocks: `importers:` → `  <dir>:` →
+ * `    dependencies:` in a workspace, or a top-level `dependencies:` block in a v5/v6
+ * single-project file. A direct pin therefore wins over a transitive copy of the same
+ * name. Every other package comes from a key exactly two columns deep under
+ * `packages:` or `snapshots:`.
+ *
+ * `instances`, when given, receives EVERY copy (a package keyed at two versions is
+ * two copies), with the `dev: true|false` that v5/v6 lockfiles write under each
+ * package key. pnpm 9 dropped that field, so its copies have unknown scope.
+ */
+export function readPnpmLock(content, versions, instances) {
+    const transitive = [];
+    const devByKey = new Map();
+    const setFirst = (name, version) => {
+        if (!versions.has(name))
+            versions.set(name, version);
+    };
+    let section = "";
+    let blockIndent = -1; // column of the dependency block being read, or -1
+    let pending = null; // v6/v9: a name whose `version:` line follows
+    let packageKey = null; // the packages/snapshots key whose fields are being read
+    for (const line of content.split(/\r?\n/)) {
+        const text = line.trim();
+        if (text === "" || text.startsWith("#"))
+            continue;
+        const indent = line.length - line.trimStart().length;
+        if (indent === 0) {
+            section = text.endsWith(":") ? text.slice(0, -1) : "";
+            blockIndent = DEPENDENCY_BLOCKS.has(text) ? 0 : -1;
+            pending = null;
+            packageKey = null;
+            continue;
+        }
+        if (section === "packages" || section === "snapshots") {
+            if (indent === 2 && text.endsWith(":")) {
+                const parsed = parsePnpmKey(text.slice(0, -1));
+                packageKey = parsed ? `${parsed[0]}\0${parsed[1]}` : null;
+                if (parsed)
+                    transitive.push(parsed);
+            }
+            else if (indent === 4 && packageKey) {
+                const dev = /^dev:\s*(true|false)\s*$/.exec(text);
+                if (dev)
+                    devByKey.set(packageKey, dev[1] === "true");
+            }
+            continue;
+        }
+        if (section === "importers" && indent <= 4) {
+            blockIndent = indent === 4 && DEPENDENCY_BLOCKS.has(text) ? 4 : -1;
+            pending = null;
+            continue;
+        }
+        if (blockIndent < 0)
+            continue;
+        if (indent === blockIndent + 2) {
+            pending = null;
+            const entry = /^(?:'([^']+)'|"([^"]+)"|([^\s:'"]+)):(?:\s+(.*))?$/.exec(text);
+            if (!entry)
+                continue;
+            const name = entry[1] ?? entry[2] ?? entry[3];
+            const value = entry[4];
+            if (value === undefined || value === "") {
+                pending = name;
+            }
+            else {
+                const version = exactVersion(value); // v5: `name: 1.2.3_peer@4.5.6`
+                if (version)
+                    setFirst(name, version);
+            }
+        }
+        else if (indent === blockIndent + 4 && pending && text.startsWith("version:")) {
+            const version = exactVersion(text.slice("version:".length));
+            if (version)
+                setFirst(pending, version);
+            pending = null;
+        }
+    }
+    for (const [name, version] of transitive)
+        setFirst(name, version);
+    if (!instances)
+        return;
+    for (const [name, version] of versions) {
+        if (!transitive.some(([n, v]) => n === name && v === version))
+            instances.add(name, version);
+    }
+    for (const [name, version] of transitive)
+        instances.add(name, version, devByKey.get(`${name}\0${version}`));
+}
+/**
+ * Reads a yarn lockfile (v1 or berry) into `versions`.
+ * v1: `"@scope/pkg@^1.0.0", "@scope/pkg@^1.1.0":` then `  version "1.2.3"`.
+ * berry: `"@scope/pkg@npm:^1.0.0":` then `  version: 1.2.3`.
+ * Workspace, link, portal, file, exec and patch entries do not name a registry version.
+ */
+export function readYarnLock(content, versions, instances, specs) {
+    for (const block of content.split(/\r?\n(?=\S)/)) {
+        const firstLine = block.split(/\r?\n/)[0];
+        const header = /^"?(@?[^@\s"]+)@/.exec(firstLine);
+        if (!header || header[1].startsWith("__"))
+            continue;
+        if (/@(?:workspace|link|portal|file|exec|patch):/.test(firstLine))
+            continue;
+        const line = /^\s+version:?\s+"?([^"\s]+)"?\s*$/m.exec(block);
+        const version = line ? exactVersion(line[1]) : null;
+        if (!version)
+            continue;
+        // One block per resolved version. Blocks are sorted by spec, so the first
+        // block of a name can be an old nested copy; `specs` lets the caller pick
+        // the copy a package.json range resolves to instead.
+        if (!versions.has(header[1]))
+            versions.set(header[1], version);
+        instances?.add(header[1], version);
+        if (specs) {
+            for (const spec of firstLine.replace(/:\s*$/, "").split(",")) {
+                specs.set(unquote(spec.trim()).replace(/@npm:/, "@"), version);
+            }
+        }
+    }
+}

package/dist/live/lockfile-parsers-pygo.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Python and Go lockfile parsers (split out of lockfile-parsers.ts).
+ *
+ * Measured 2026-10-02 against osv-scanner and pip-audit, every miss below was
+ * a parsing loss before OSV was ever asked:
+ * - requirements.txt: `urllib3[secure]==1.25.0` and dotted names were skipped,
+ *   and an inline comment rode along as part of the version — OSV was asked
+ *   about `"8.0.0  # imaging"` and answered with 63 advisories for the real 45.
+ * - poetry.lock: the reader required `name` and `version` on consecutive
+ *   lines. Poetry before 1.0 wrote its keys alphabetically (`category`,
+ *   `description`, `name`, ..., `version`), so a whole lockfile read as empty.
+ * - go.sum: `(v[\d.]+)` cut `v0.0.0-20200622213623-75b288015ac9` to `v0.0.0`
+ *   and dropped `+incompatible`; `v0.0.0` then sorted AFTER the real
+ *   pseudo-version, so older advisories were missed and later ones invented.
+ *   go.sum also lists versions the build never selected.
+ */
+import { InstanceSet, type VersionSource } from "./lockfile-types.js";
+/** PEP 503 normalised name: lowercase, runs of `-`, `_`, `.` become one `-`. */
+export declare function normalizePythonName(name: string): string;
+export declare function resolvePython(cwd: string): VersionSource;
+/**
+ * [[package]] tables from poetry.lock (any version) or uv.lock. A pre-1.2
+ * poetry.lock records `category = "dev"` for dev-only packages; newer files
+ * and uv.lock do not record scope here, so it stays unknown.
+ */
+export declare function readTomlPackageLock(content: string): {
+    versions: Map<string, string>;
+    instances: InstanceSet;
+};
+/**
+ * Exact pins from a requirements file: `name==1.2`, `name===1.2`,
+ * `name[extra1,extra2]==1.2`, with environment markers and inline comments.
+ * Ranges (`>=`, `~=`) do not name an installed version and are skipped, as are
+ * options (`-r`, `-e`, `--hash`) and URL requirements.
+ */
+export declare function parseRequirements(content: string): Array<{
+    name: string;
+    version: string;
+}>;
+export declare function resolveGo(cwd: string): VersionSource;
+/** `require` lines (block and single form) with `replace` applied, and whether the go directive is >= 1.17. */
+export declare function parseGoMod(content: string): {
+    requires: Array<{
+        module: string;
+        version: string;
+        indirect: boolean;
+    }>;
+    goVersionAtLeast117: boolean;
+};
+/**
+ * Per module, the highest version go.sum records — minimal version selection
+ * picks the highest required version, and go.sum records every version the
+ * module graph required. A module listed only by its `/go.mod` hash is still
+ * in Go's build list (`go list -m all`): measured 2026-10-02 on gh cli v1.0
+ * (go 1.13), skipping those lines missed 14 advisories (grpc 1.21.0,
+ * jwt-go, gorilla/websocket, ...) the build list carries.
+ */
+export declare function selectedFromGoSum(content: string): Map<string, string>;
+/** Semver precedence over Go versions; build metadata (`+incompatible`) is ignored. */
+export declare function compareGoVersions(a: string, b: string): number;