weavatrix 0.1.1 → 0.1.3

package/src/security/advisory-store.js

@@ -10,6 +10,7 @@
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { homedir } from "node:os";
+import { createHash } from "node:crypto";
 import { uniqueBy } from "../util.js";
 
 export const DEFAULT_STORE = join(homedir(), ".weavatrix", "advisories.json");
@@ -22,6 +23,13 @@ const keyOf = (ecosystem, name) => `${ecosystem}|${ecosystem === "PyPI" ? String
 
 const uniquePackages = (pkgs) => uniqueBy(pkgs, (p) => `${p.ecosystem}|${p.name}|${p.version}`);
 
+export function advisoryQueryFingerprint(installed = []) {
+  const rows = uniquePackages(installed.filter((p) => p?.ecosystem && p?.name && p?.version && OSV_SUPPORTED_ECOSYSTEMS.has(p.ecosystem)))
+    .map((p) => `${p.ecosystem}|${p.name}|${p.version}`)
+    .sort();
+  return createHash("sha256").update(rows.join("\n"), "utf8").digest("hex");
+}
+
 async function fetchJson(fetcher, url, options, timeoutMs) {
   const timeout = Math.max(50, Number(timeoutMs) || DEFAULT_FETCH_TIMEOUT_MS);
   const ctrl = typeof AbortController === "function" ? new AbortController() : null;
@@ -119,6 +127,7 @@ export async function refreshAdvisories({ installed = [], storePath = DEFAULT_ST
   const store = loadStore(storePath);
   const idsByPkg = new Map(); // pkgIndex -> [vuln ids]
   const errors = [];
+  let queriedOk = 0;
 
   for (let i = 0; i < pkgs.length; i += batchSize) {
     const batch = pkgs.slice(i, i + batchSize);
@@ -128,7 +137,22 @@ export async function refreshAdvisories({ installed = [], storePath = DEFAULT_ST
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify({ queries: batch.map((p) => ({ package: { ecosystem: p.ecosystem, name: p.name }, version: p.version })) }),
       }, timeoutMs);
-      (json.results || []).forEach((r, j) => { if (r && Array.isArray(r.vulns) && r.vulns.length) idsByPkg.set(i + j, r.vulns.map((v) => v.id)); });
+      if (!Array.isArray(json?.results) || json.results.length !== batch.length) {
+        throw new Error(`OSV querybatch returned ${Array.isArray(json?.results) ? json.results.length : "no"} result(s) for ${batch.length} query item(s)`);
+      }
+      for (const [resultIndex, result] of json.results.entries()) {
+        if (!result || typeof result !== "object" || Array.isArray(result)) {
+          throw new Error(`OSV querybatch result ${resultIndex + 1} is not an object`);
+        }
+        if (result.vulns !== undefined && !Array.isArray(result.vulns)) {
+          throw new Error(`OSV querybatch result ${resultIndex + 1} has a non-array vulns field`);
+        }
+        if (Array.isArray(result.vulns) && result.vulns.some((v) => !v || typeof v.id !== "string" || !v.id.trim())) {
+          throw new Error(`OSV querybatch result ${resultIndex + 1} contains an advisory without a valid id`);
+        }
+      }
+      queriedOk += batch.length;
+      json.results.forEach((r, j) => { if (r && Array.isArray(r.vulns) && r.vulns.length) idsByPkg.set(i + j, r.vulns.map((v) => v.id)); });
     } catch (error) {
       errors.push(`querybatch ${Math.floor(i / batchSize) + 1}/${Math.ceil(pkgs.length / batchSize)}: ${error.message}`);
     }
@@ -141,16 +165,24 @@ export async function refreshAdvisories({ installed = [], storePath = DEFAULT_ST
   for (const [id, pkgList] of wanted) {
     try {
       const rec = await fetchJson(fetcher, OSV_VULN_URL + encodeURIComponent(id), {}, timeoutMs);
-      if (!rec || !rec.id) continue;
-      fetched++;
+      if (!rec || typeof rec.id !== "string" || !rec.id) throw new Error("OSV detail response is missing its advisory id");
+      if (rec.id !== id) throw new Error(`OSV detail id mismatch (expected ${id}, received ${rec.id})`);
+      let normalized = 0;
       for (const p of pkgList) {
         const row = normalizeRecord(rec, p.ecosystem, p.name);
-        if (!row) continue;
+        if (!row) {
+          errors.push(`${id}: OSV detail does not describe ${p.ecosystem}:${p.name} reported by querybatch`);
+          continue;
+        }
+        normalized++;
         const key = keyOf(p.ecosystem, p.name);
         const list = store.records[key] || (store.records[key] = []);
         const at = list.findIndex((x) => x.id === row.id);
         if (at >= 0) list[at] = row; else list.push(row);
       }
+      // Count a detail response as fetched only after at least one package-specific row was
+      // validated. A malformed or unrelated response must never make coverage look complete.
+      if (normalized > 0) fetched++;
     } catch (error) {
       errors.push(`${id}: ${error.message}`);
     }
@@ -158,20 +190,32 @@ export async function refreshAdvisories({ installed = [], storePath = DEFAULT_ST
 
   // A refresh where NOTHING was fetched but errors occurred (offline, OSV blocked) must NOT stamp
   // fetched_at — that would turn an empty cache into "No known vulnerabilities as of <today>".
-  if (errors.length && fetched === 0 && (idsByPkg.size === 0 || wanted.size > 0)) {
+  if (errors.length && queriedOk === 0) {
     return { ok: false, queried: pkgs.length, unsupported, error: `advisory refresh failed: ${errors[0]}${errors.length > 1 ? ` (+${errors.length - 1} more)` : ""}`, errors };
   }
   store.meta.fetched_at = new Date().toISOString();
+  const status = errors.length ? "PARTIAL" : "OK";
   // per-repo stamp: the cache only covers packages that were QUERIED — a repo that never refreshed must
   // show "fetch advisories", not "0 vulnerabilities as of <someone else's date>" (false assurance).
   // repoKeys[] lets one online pass (a "refresh all repos") stamp every repo whose packages it covered.
   const stampRepos = [...new Set([repoKey, ...repoKeys].filter(Boolean))];
-  if (stampRepos.length) { store.meta.repos = store.meta.repos || {}; for (const k of stampRepos) store.meta.repos[k] = store.meta.fetched_at; }
+  if (stampRepos.length) {
+    store.meta.repos = store.meta.repos || {};
+    for (const k of stampRepos) store.meta.repos[k] = {
+      fetched_at: store.meta.fetched_at,
+      status,
+      queried: pkgs.length,
+      queried_ok: queriedOk,
+      unsupported,
+      error_count: errors.length,
+      query_fingerprint: advisoryQueryFingerprint(pkgs),
+    };
+  }
   try {
     mkdirSync(dirname(storePath), { recursive: true });
     writeFileSync(storePath, JSON.stringify(store), "utf8");
   } catch (error) {
     return { ok: false, error: `store write failed: ${error.message}`, errors };
   }
-  return { ok: true, queried: pkgs.length, unsupported, vulnerable: wanted.size, fetched, saved: existsSync(storePath), errors };
+  return { ok: true, status, queried: pkgs.length, queriedOk, unsupported, vulnerable: wanted.size, fetched, saved: existsSync(storePath), errors };
 }

package/src/security/installed.js

@@ -2,10 +2,11 @@
 // (package-lock v1/v2/v3, basic yarn.lock, requirements.txt ==pins, go.sum), plus a top-level
 // node_modules walk — which also yields the lockfile-DRIFT signal (installed ≠ locked → tampering or
 // stale install). Parsers are pure + exported for tests; collectInstalled is the thin fs wrapper.
-import { existsSync, readFileSync, readdirSync } from "node:fs";
-import { join } from "node:path";
+import { readFileSync, readdirSync } from "node:fs";
+import { join, relative } from "node:path";
 import { parseGoMod } from "../analysis/manifests.js";
 import { uniqueBy } from "../util.js";
+import { createRepoBoundary } from "../repo-path.js";
 
 const pep503 = (name) => String(name).toLowerCase().replace(/[-_.]+/g, "-"); // PyPI canonical name
 
@@ -144,21 +145,19 @@ export function parseGoModPackages(text) {
 }
 
 // Top-level node_modules walk (incl. @scopes): the ground truth of what is REALLY on disk.
-function walkNodeModules(repoPath) {
+function walkNodeModules(repoPath, { readJsonFile = readJson, readdir = readdirSync } = {}) {
   const out = [];
   const nm = join(repoPath, "node_modules");
   const readPkg = (dir, name) => {
-    try {
-      const pj = JSON.parse(readFileSync(join(dir, "package.json"), "utf8"));
-      if (pj && pj.version) out.push({ ecosystem: "npm", name: pj.name || name, version: pj.version, dev: false, integrity: "", source: "node_modules" });
-    } catch { /* not a package dir */ }
+    const pj = readJsonFile(join(dir, "package.json"));
+    if (pj && pj.version) out.push({ ecosystem: "npm", name: pj.name || name, version: pj.version, dev: false, integrity: "", source: "node_modules" });
   };
   let entries;
-  try { entries = readdirSync(nm); } catch { return out; }
+  try { entries = readdir(nm); } catch { return out; }
   for (const e of entries) {
     if (e.startsWith(".")) continue;
     if (e.startsWith("@")) {
-      let scoped; try { scoped = readdirSync(join(nm, e)); } catch { continue; }
+      let scoped; try { scoped = readdir(join(nm, e)); } catch { continue; }
       for (const s of scoped) readPkg(join(nm, e, s), `${e}/${s}`);
     } else readPkg(join(nm, e), e);
   }
@@ -170,58 +169,72 @@ const readJson = (p) => { try { return JSON.parse(readFileSync(p, "utf8")); } ca
 
 const SUBPROJECT_SKIP = new Set([".git", ".idea", ".vscode", ".venv", "venv", "env", "node_modules", "vendor", "dist", "build", "coverage", "__pycache__", ".tox", "testdata"]);
 
-function projectDirs(repoPath) {
-  const dirs = [repoPath];
+function projectDirs(boundary) {
+  const dirs = boundary.root ? [boundary.root] : [];
   let entries = [];
-  try { entries = readdirSync(repoPath, { withFileTypes: true }); } catch { return dirs; }
+  try { entries = readdirSync(boundary.root, { withFileTypes: true }); } catch { return dirs; }
   for (const e of entries) {
     if (!e.isDirectory() || e.name.startsWith(".") || SUBPROJECT_SKIP.has(e.name)) continue;
-    dirs.push(join(repoPath, e.name));
+    const resolved = boundary.resolve(e.name);
+    if (resolved.ok) dirs.push(resolved.path);
     if (dirs.length >= 101) break;
   }
   return dirs;
 }
 
-function collectReqFiles(dir) {
+function collectReqFiles(dir, readdir = readdirSync) {
   const reqFiles = [];
-  try { for (const n of readdirSync(dir)) if (/^requirements[\w.-]*\.(txt|in)$/i.test(n)) reqFiles.push(join(dir, n)); } catch { /* unreadable root */ }
-  try { for (const n of readdirSync(join(dir, "requirements"))) if (/\.(txt|in)$/i.test(n)) reqFiles.push(join(dir, "requirements", n)); } catch { /* no requirements/ dir */ }
+  try { for (const n of readdir(dir)) if (/^requirements[\w.-]*\.(txt|in)$/i.test(n)) reqFiles.push(join(dir, n)); } catch { /* unreadable root */ }
+  try { for (const n of readdir(join(dir, "requirements"))) if (/\.(txt|in)$/i.test(n)) reqFiles.push(join(dir, "requirements", n)); } catch { /* no requirements/ dir */ }
   return reqFiles;
 }
 
 // → { installed: [{ecosystem,name,version,dev,source}], drift: [{name, locked, installed}] }
 export function collectInstalled(repoPath) {
-  const dirs = projectDirs(repoPath);
+  const boundary = createRepoBoundary(repoPath);
+  if (!boundary.root) return { installed: [], drift: [] };
+  const inside = (path) => boundary.resolve(relative(boundary.root, path) || ".");
+  const boundedText = (path) => { const resolved = inside(path); return resolved.ok ? readText(resolved.path) : null; };
+  const boundedJson = (path) => { const resolved = inside(path); return resolved.ok ? readJson(resolved.path) : null; };
+  const boundedReaddir = (path, options) => {
+    const resolved = inside(path);
+    if (!resolved.ok) throw new Error("path is outside the repository");
+    return readdirSync(resolved.path, options);
+  };
+  const dirs = projectDirs(boundary);
   const lock = [];
   const yarn = [];
   const disk = [];
   for (const dir of dirs) {
-    const lockHere = parsePackageLock(readJson(join(dir, "package-lock.json")) || {});
+    const lockHere = parsePackageLock(boundedJson(join(dir, "package-lock.json")) || {});
     lock.push(...lockHere);
-    if (!lockHere.length) yarn.push(...parseYarnLock(readText(join(dir, "yarn.lock")) || ""));
-    disk.push(...walkNodeModules(dir));
+    if (!lockHere.length) yarn.push(...parseYarnLock(boundedText(join(dir, "yarn.lock")) || ""));
+    disk.push(...walkNodeModules(dir, { readJsonFile: boundedJson, readdir: boundedReaddir }));
   }
   // Python: venv site-packages = the ground truth (exact installed versions); requirements*.txt (root +
   // a requirements/ dir) and poetry/uv/Pipfile locks fill in when there's no venv. venv wins per name.
-  const venvPy = dirs.flatMap((dir) => collectVenvPackages(dir));
-  const reqFiles = dirs.flatMap((dir) => collectReqFiles(dir));
+  const venvPy = dirs.flatMap((dir) => collectVenvPackages(dir, { readdir: boundedReaddir }));
+  const reqFiles = dirs.flatMap((dir) => collectReqFiles(dir, boundedReaddir));
   const venvNames = new Set(venvPy.map((p) => p.name));
   const pyDeclared = [
-    ...reqFiles.flatMap((f) => parseRequirements(readText(f) || "")),
-    ...dirs.flatMap((dir) => parseTomlLockPackages(readText(join(dir, "poetry.lock")) || "", "poetry-lock")),
-    ...dirs.flatMap((dir) => parseTomlLockPackages(readText(join(dir, "uv.lock")) || "", "uv-lock")),
-    ...dirs.flatMap((dir) => parsePipfileLock(readJson(join(dir, "Pipfile.lock")) || null)),
+    ...reqFiles.flatMap((f) => parseRequirements(boundedText(f) || "")),
+    ...dirs.flatMap((dir) => parseTomlLockPackages(boundedText(join(dir, "poetry.lock")) || "", "poetry-lock")),
+    ...dirs.flatMap((dir) => parseTomlLockPackages(boundedText(join(dir, "uv.lock")) || "", "uv-lock")),
+    ...dirs.flatMap((dir) => parsePipfileLock(boundedJson(join(dir, "Pipfile.lock")) || null)),
   ].filter((p) => !venvNames.has(p.name)); // installed version supersedes the declared pin
   const py = [...venvPy, ...pyDeclared];
   // Go: go.sum (exact, hashed) first, then go.mod require versions as a fallback. Walk the repo root
   // AND its immediate subdirectories so a Go MONOREPO (per-folder modules, no root go.mod — e.g. gpro)
   // still scans; dedupe() collapses the go.sum/go.mod overlap and cross-module shared deps.
-  const goFromDir = (dir) => [...parseGoSum(readText(join(dir, "go.sum")) || ""), ...parseGoModPackages(readText(join(dir, "go.mod")) || "")];
-  const go = [...goFromDir(repoPath)];
-  if (!go.length || existsSync(join(repoPath, "go.work"))) {
+  const goFromDir = (dir) => [...parseGoSum(boundedText(join(dir, "go.sum")) || ""), ...parseGoModPackages(boundedText(join(dir, "go.mod")) || "")];
+  const go = [...goFromDir(boundary.root)];
+  if (!go.length || boundary.resolve("go.work").ok) {
     let subs = [];
-    try { subs = readdirSync(repoPath, { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith(".") && !["node_modules", "vendor", "dist", "build", "testdata"].includes(e.name)); } catch { /* unreadable root */ }
-    for (const s of subs.slice(0, 100)) go.push(...goFromDir(join(repoPath, s.name)));
+    try { subs = boundedReaddir(boundary.root, { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith(".") && !["node_modules", "vendor", "dist", "build", "testdata"].includes(e.name)); } catch { /* unreadable root */ }
+    for (const s of subs.slice(0, 100)) {
+      const resolved = boundary.resolve(s.name);
+      if (resolved.ok) go.push(...goFromDir(resolved.path));
+    }
   }
 
   // lockfile wins as the version source; disk fills gaps + powers the drift signal. A package

package/src/security/malware-heuristics.exclusions.js

@@ -1,134 +1,134 @@
-// Allowlist/exclusion parsing and URL/doc-noise filters for the malware scanner (split out of
-// malware-heuristics.js; see that file for the scanner overview).
-import { NOISY_URL_KEYS, isDocFile, isBenignUrlContext } from "./registry-sig.js";
-
-export const normPath = (p) => String(p || "").replace(/\\/g, "/").replace(/\/+$/, "");
-const URL_RULE_KEYS = new Set(["exfil-url", "exfil-ip", "cloud-metadata-url", "network-url", "hardcoded-url"]);
-const URL_RE = /https?:\/\/[^\s'"`)\\<>]+/gi;
-const PACKAGE_JSON_SCRIPT_RE = /["']?(preinstall|install|postinstall|prepare|prepack|postpack|prepublish|prepublishonly)["']?\s*:/i;
-const PACKAGE_JSON_METADATA_URL_RE = /["']?(bugs|homepage|repository|funding|author|contributors|maintainers|publishConfig|license)["']?\s*:|["']?url["']?\s*:/i;
-const NETWORK_CALL_RE = /\b(fetch|axios\.|XMLHttpRequest|sendBeacon|https?\.request|request\(|curl\b|wget\b|iwr\b|invoke-webrequest)\b/i;
-const LIFECYCLE_SCRIPT_HOOKS = ["preinstall", "install", "postinstall", "prepare"];
-
-function cleanUrlToken(value) {
-  return String(value || "").trim().replace(/[.,;:!?]+$/g, "").replace(/[)\]}]+$/g, "");
-}
-
-function splitAllowlistText(value) {
-  if (Array.isArray(value)) return value.flatMap(splitAllowlistText);
-  return String(value || "")
-    .split(/[\r\n,]+/)
-    .map((line) => line.replace(/\s+#.*$/, "").trim())
-    .filter(Boolean);
-}
-
-function normalizeHost(value) {
-  let s = String(value || "").trim().toLowerCase();
-  if (!s) return "";
-  try {
-    if (/^https?:\/\//i.test(s)) s = new URL(s).host;
-  } catch { /* keep raw */ }
-  return s.replace(/^\*\./, "").replace(/^\./, "").replace(/:\d+$/, "");
-}
-
-function normalizeUrl(value) {
-  const raw = cleanUrlToken(value);
-  if (!raw) return "";
-  try {
-    const u = new URL(raw);
-    const path = u.pathname.replace(/\/+$/, "");
-    return `${u.protocol.toLowerCase()}//${u.host.toLowerCase()}${path}${u.search || ""}`;
-  } catch {
-    return raw.toLowerCase().replace(/\/+$/, "");
-  }
-}
-
-function extractUrls(text) {
-  return [...String(text || "").matchAll(URL_RE)].map((m) => cleanUrlToken(m[0])).filter(Boolean);
-}
-
-function urlMatchesAllow(allowUrl, candidate) {
-  const a = normalizeUrl(allowUrl);
-  const c = normalizeUrl(candidate);
-  if (!a || !c) return false;
-  return c === a || c.startsWith(`${a}/`) || a.startsWith(`${c}/`);
-}
-
-function hostMatchesAllow(allowHost, candidate) {
-  const a = normalizeHost(allowHost);
-  const c = normalizeHost(candidate);
-  return !!(a && c && (c === a || c.endsWith(`.${a}`)));
-}
-
-export function parseMalwareExclusions(input = {}) {
-  const out = { urls: [], hosts: [], packages: [], rules: [] };
-  const add = (raw) => {
-    const s = cleanUrlToken(raw);
-    if (!s) return;
-    const lower = s.toLowerCase();
-    if (lower.startsWith("pkg:")) { out.packages.push(s.slice(4).trim()); return; }
-    if (lower.startsWith("package:")) { out.packages.push(s.slice(8).trim()); return; }
-    if (lower.startsWith("rule:")) { out.rules.push(s.slice(5).trim()); return; }
-    if (lower.startsWith("host:")) { out.hosts.push(normalizeHost(s.slice(5))); return; }
-    if (lower.startsWith("domain:")) { out.hosts.push(normalizeHost(s.slice(7))); return; }
-    if (/^https?:\/\//i.test(s)) { out.urls.push(normalizeUrl(s)); out.hosts.push(normalizeHost(s)); return; }
-    if (!s.includes("/") && s.includes(".")) { out.hosts.push(normalizeHost(s)); return; }
-    out.packages.push(s);
-  };
-  if (typeof input === "string" || Array.isArray(input)) {
-    for (const line of splitAllowlistText(input)) add(line);
-  } else if (input && typeof input === "object") {
-    for (const line of splitAllowlistText(input.urls || input.url || "")) add(line);
-    for (const line of splitAllowlistText(input.domains || input.domain || "")) add(`host:${line}`);
-    for (const line of splitAllowlistText(input.packages || input.package || "")) add(/^pkg(age)?:/i.test(line) ? line : `pkg:${line}`);
-    for (const line of splitAllowlistText(input.rules || input.rule || "")) add(`rule:${line}`);
-  }
-  return {
-    urls: [...new Set(out.urls.filter(Boolean))],
-    hosts: [...new Set(out.hosts.filter(Boolean))],
-    packages: [...new Set(out.packages.map((p) => p.trim()).filter(Boolean))],
-    rules: [...new Set(out.rules.map((r) => r.trim()).filter(Boolean))],
-  };
-}
-
-export function isManifestUrlNoise(file, signal) {
-  if (!URL_RULE_KEYS.has(signal?.key)) return false;
-  const f = normPath(file).toLowerCase();
-  const text = `${signal?.snippet || ""}`.trim();
-  if (/(^|\/)package\.json$/.test(f)) {
-    if (PACKAGE_JSON_SCRIPT_RE.test(text)) return false;
-    return PACKAGE_JSON_METADATA_URL_RE.test(text) || !NETWORK_CALL_RE.test(text);
-  }
-  return /(^|\/)(pkg-info|metadata)$/.test(f);
-}
-
-export function lifecycleScriptSnippet(scripts = {}) {
-  for (const hook of LIFECYCLE_SCRIPT_HOOKS) {
-    const s = String(scripts?.[hook] || "").trim();
-    if (s) return `${hook}: ${s}`.slice(0, 200);
-  }
-  return "";
-}
-
-// weak URL rules only: URL evidence in a license/prose file or in comment/doc-link context is
-// documentation, not behavior (LICENSE:5 "http://www.apache.org/licenses/" was the hot FP).
-// Strong rules (miner/shell/exfil-url) are untouched and still scan those same files.
-export function isDocUrlNoise(file, signal) {
-  if (!NOISY_URL_KEYS.has(signal?.key)) return false;
-  return isDocFile(file) || isBenignUrlContext(signal?.snippet || "");
-}
-
-export function isMalwareSignalExcluded(pkg, signal, exclusions = {}) {
-  const ex = exclusions.urls || exclusions.hosts || exclusions.packages || exclusions.rules ? exclusions : parseMalwareExclusions(exclusions);
-  if (signal?.key && ex.rules.includes(signal.key)) return true;
-  if (ex.packages.some((p) => p.toLowerCase() === String(pkg || "").toLowerCase()) && signal?.noisy) return true;
-  if (!URL_RULE_KEYS.has(signal?.key)) return false;
-  const text = `${signal?.snippet || ""}\n${signal?.file || ""}`;
-  const urls = extractUrls(text);
-  for (const url of urls) {
-    if (ex.urls.some((allowed) => urlMatchesAllow(allowed, url))) return true;
-    if (ex.hosts.some((allowed) => hostMatchesAllow(allowed, url))) return true;
-  }
-  if (!urls.length && ex.hosts.some((host) => host && text.toLowerCase().includes(host))) return true;
-  return false;
-}
+// Allowlist/exclusion parsing and URL/doc-noise filters for the malware scanner (split out of
+// malware-heuristics.js; see that file for the scanner overview).
+import { NOISY_URL_KEYS, isDocFile, isBenignUrlContext } from "./registry-sig.js";
+
+export const normPath = (p) => String(p || "").replace(/\\/g, "/").replace(/\/+$/, "");
+const URL_RULE_KEYS = new Set(["exfil-url", "exfil-ip", "cloud-metadata-url", "network-url", "hardcoded-url"]);
+const URL_RE = /https?:\/\/[^\s'"`)\\<>]+/gi;
+const PACKAGE_JSON_SCRIPT_RE = /["']?(preinstall|install|postinstall|prepare|prepack|postpack|prepublish|prepublishonly)["']?\s*:/i;
+const PACKAGE_JSON_METADATA_URL_RE = /["']?(bugs|homepage|repository|funding|author|contributors|maintainers|publishConfig|license)["']?\s*:|["']?url["']?\s*:/i;
+const NETWORK_CALL_RE = /\b(fetch|axios\.|XMLHttpRequest|sendBeacon|https?\.request|request\(|curl\b|wget\b|iwr\b|invoke-webrequest)\b/i;
+const LIFECYCLE_SCRIPT_HOOKS = ["preinstall", "install", "postinstall", "prepare"];
+
+function cleanUrlToken(value) {
+  return String(value || "").trim().replace(/[.,;:!?]+$/g, "").replace(/[)\]}]+$/g, "");
+}
+
+function splitAllowlistText(value) {
+  if (Array.isArray(value)) return value.flatMap(splitAllowlistText);
+  return String(value || "")
+    .split(/[\r\n,]+/)
+    .map((line) => line.replace(/\s+#.*$/, "").trim())
+    .filter(Boolean);
+}
+
+function normalizeHost(value) {
+  let s = String(value || "").trim().toLowerCase();
+  if (!s) return "";
+  try {
+    if (/^https?:\/\//i.test(s)) s = new URL(s).host;
+  } catch { /* keep raw */ }
+  return s.replace(/^\*\./, "").replace(/^\./, "").replace(/:\d+$/, "");
+}
+
+function normalizeUrl(value) {
+  const raw = cleanUrlToken(value);
+  if (!raw) return "";
+  try {
+    const u = new URL(raw);
+    const path = u.pathname.replace(/\/+$/, "");
+    return `${u.protocol.toLowerCase()}//${u.host.toLowerCase()}${path}${u.search || ""}`;
+  } catch {
+    return raw.toLowerCase().replace(/\/+$/, "");
+  }
+}
+
+function extractUrls(text) {
+  return [...String(text || "").matchAll(URL_RE)].map((m) => cleanUrlToken(m[0])).filter(Boolean);
+}
+
+function urlMatchesAllow(allowUrl, candidate) {
+  const a = normalizeUrl(allowUrl);
+  const c = normalizeUrl(candidate);
+  if (!a || !c) return false;
+  return c === a || c.startsWith(`${a}/`) || a.startsWith(`${c}/`);
+}
+
+function hostMatchesAllow(allowHost, candidate) {
+  const a = normalizeHost(allowHost);
+  const c = normalizeHost(candidate);
+  return !!(a && c && (c === a || c.endsWith(`.${a}`)));
+}
+
+export function parseMalwareExclusions(input = {}) {
+  const out = { urls: [], hosts: [], packages: [], rules: [] };
+  const add = (raw) => {
+    const s = cleanUrlToken(raw);
+    if (!s) return;
+    const lower = s.toLowerCase();
+    if (lower.startsWith("pkg:")) { out.packages.push(s.slice(4).trim()); return; }
+    if (lower.startsWith("package:")) { out.packages.push(s.slice(8).trim()); return; }
+    if (lower.startsWith("rule:")) { out.rules.push(s.slice(5).trim()); return; }
+    if (lower.startsWith("host:")) { out.hosts.push(normalizeHost(s.slice(5))); return; }
+    if (lower.startsWith("domain:")) { out.hosts.push(normalizeHost(s.slice(7))); return; }
+    if (/^https?:\/\//i.test(s)) { out.urls.push(normalizeUrl(s)); out.hosts.push(normalizeHost(s)); return; }
+    if (!s.includes("/") && s.includes(".")) { out.hosts.push(normalizeHost(s)); return; }
+    out.packages.push(s);
+  };
+  if (typeof input === "string" || Array.isArray(input)) {
+    for (const line of splitAllowlistText(input)) add(line);
+  } else if (input && typeof input === "object") {
+    for (const line of splitAllowlistText(input.urls || input.url || "")) add(line);
+    for (const line of splitAllowlistText(input.domains || input.domain || "")) add(`host:${line}`);
+    for (const line of splitAllowlistText(input.packages || input.package || "")) add(/^pkg(age)?:/i.test(line) ? line : `pkg:${line}`);
+    for (const line of splitAllowlistText(input.rules || input.rule || "")) add(`rule:${line}`);
+  }
+  return {
+    urls: [...new Set(out.urls.filter(Boolean))],
+    hosts: [...new Set(out.hosts.filter(Boolean))],
+    packages: [...new Set(out.packages.map((p) => p.trim()).filter(Boolean))],
+    rules: [...new Set(out.rules.map((r) => r.trim()).filter(Boolean))],
+  };
+}
+
+export function isManifestUrlNoise(file, signal) {
+  if (!URL_RULE_KEYS.has(signal?.key)) return false;
+  const f = normPath(file).toLowerCase();
+  const text = `${signal?.snippet || ""}`.trim();
+  if (/(^|\/)package\.json$/.test(f)) {
+    if (PACKAGE_JSON_SCRIPT_RE.test(text)) return false;
+    return PACKAGE_JSON_METADATA_URL_RE.test(text) || !NETWORK_CALL_RE.test(text);
+  }
+  return /(^|\/)(pkg-info|metadata)$/.test(f);
+}
+
+export function lifecycleScriptSnippet(scripts = {}) {
+  for (const hook of LIFECYCLE_SCRIPT_HOOKS) {
+    const s = String(scripts?.[hook] || "").trim();
+    if (s) return `${hook}: ${s}`.slice(0, 200);
+  }
+  return "";
+}
+
+// weak URL rules only: URL evidence in a license/prose file or in comment/doc-link context is
+// documentation, not behavior (LICENSE:5 "http://www.apache.org/licenses/" was the hot FP).
+// Strong rules (miner/shell/exfil-url) are untouched and still scan those same files.
+export function isDocUrlNoise(file, signal) {
+  if (!NOISY_URL_KEYS.has(signal?.key)) return false;
+  return isDocFile(file) || isBenignUrlContext(signal?.snippet || "");
+}
+
+export function isMalwareSignalExcluded(pkg, signal, exclusions = {}) {
+  const ex = exclusions.urls || exclusions.hosts || exclusions.packages || exclusions.rules ? exclusions : parseMalwareExclusions(exclusions);
+  if (signal?.key && ex.rules.includes(signal.key)) return true;
+  if (ex.packages.some((p) => p.toLowerCase() === String(pkg || "").toLowerCase()) && signal?.noisy) return true;
+  if (!URL_RULE_KEYS.has(signal?.key)) return false;
+  const text = `${signal?.snippet || ""}\n${signal?.file || ""}`;
+  const urls = extractUrls(text);
+  for (const url of urls) {
+    if (ex.urls.some((allowed) => urlMatchesAllow(allowed, url))) return true;
+    if (ex.hosts.some((allowed) => hostMatchesAllow(allowed, url))) return true;
+  }
+  if (!urls.length && ex.hosts.some((host) => host && text.toLowerCase().includes(host))) return true;
+  return false;
+}

package/src/security/malware-heuristics.js

@@ -1,15 +1,15 @@
-// Heuristic malware scanner over INSTALLED dependencies (defensive): install-script beacons, crypto-
-// miner signatures, exfiltration endpoints, obfuscation markers, non-registry install sources.
-// Phase A (always, cheap): every installed package's package.json scripts + lockfile `resolved` origin.
-// Phase B (content): ripgrep sweep of node_modules when rg is available (full coverage), else a bounded
-// Node fallback over each package's entry files. Multi-signal scoring per package: high/critical needs
-// a near-zero-FP rule OR >=2 independent rule keys; the allowlist downgrades ONLY noisy rules.
-// This catches known PATTERNS — it is not a sandbox or a reputation service (honest limit, in the UI).
-// Split into sibling modules (this file stays the import path):
-//   malware-heuristics.exclusions.js - allowlist parsing + URL/doc noise filters
-//   malware-heuristics.roots.js      - content roots + path-to-package mapping
-//   malware-heuristics.sweep.js      - ripgrep / Node content sweeps
-//   malware-heuristics.scan.js       - scanMalware orchestration
-export { parseMalwareExclusions, isMalwareSignalExcluded } from "./malware-heuristics.exclusions.js";
-export { pkgOfNodeModulesPath } from "./malware-heuristics.roots.js";
-export { scanMalware } from "./malware-heuristics.scan.js";
+// Heuristic malware scanner over INSTALLED dependencies (defensive): install-script beacons, crypto-
+// miner signatures, exfiltration endpoints, obfuscation markers, non-registry install sources.
+// Phase A (always, cheap): every installed package's package.json scripts + lockfile `resolved` origin.
+// Phase B (content): ripgrep sweep of node_modules when rg is available (full coverage), else a bounded
+// Node fallback over each package's entry files. Multi-signal scoring per package: high/critical needs
+// a near-zero-FP rule OR >=2 independent rule keys; the allowlist downgrades ONLY noisy rules.
+// This catches known PATTERNS — it is not a sandbox or a reputation service (honest limit, in the UI).
+// Split into sibling modules (this file stays the import path):
+//   malware-heuristics.exclusions.js - allowlist parsing + URL/doc noise filters
+//   malware-heuristics.roots.js      - content roots + path-to-package mapping
+//   malware-heuristics.sweep.js      - ripgrep / Node content sweeps
+//   malware-heuristics.scan.js       - scanMalware orchestration
+export { parseMalwareExclusions, isMalwareSignalExcluded } from "./malware-heuristics.exclusions.js";
+export { pkgOfNodeModulesPath } from "./malware-heuristics.roots.js";
+export { scanMalware } from "./malware-heuristics.scan.js";