weavatrix 0.3.14 → 1.0.0

package/src/security/installed.js

@@ -1,280 +0,0 @@
-// Installed-package enumeration for supply-chain scanning: EXACT versions from lockfiles first
-// (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 { 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";
-import { collectJvmRustInstalled } from "./installed-jvm-rust.js";
-import { listRepoFiles, readRepoText } from "../analysis/internal-audit/repo-files.js";
-
-const pep503 = (name) => String(name).toLowerCase().replace(/[-_.]+/g, "-"); // PyPI canonical name
-
-const dedupe = (list) => uniqueBy(list, (p) => `${p.ecosystem}|${p.name}|${p.version}`);
-
-export function parsePackageLock(json) {
-  const out = [];
-  const lockTracksScripts = Number(json?.lockfileVersion || 0) >= 2;
-  if (json && json.packages && typeof json.packages === "object") { // v2/v3
-    for (const [key, v] of Object.entries(json.packages)) {
-      if (!key.startsWith("node_modules/") || !v || !v.version) continue;
-      const name = key.slice(key.lastIndexOf("node_modules/") + "node_modules/".length); // nested a/node_modules/b → b
-      if (!name || name.startsWith(".")) continue;
-      const depth = key.split("node_modules/").length - 1; // 1 = hoisted top-level, 2+ = nested duplicate
-      out.push({ ecosystem: "npm", name, version: v.version, dev: !!v.dev, integrity: v.integrity || "", resolved: v.resolved || "", source: "package-lock", depth, hasInstallScript: lockTracksScripts ? !!v.hasInstallScript : undefined });
-    }
-  } else if (json && json.dependencies) { // v1 recursive tree
-    const walk = (deps, depth) => {
-      for (const [name, v] of Object.entries(deps || {})) {
-        if (v && v.version) out.push({ ecosystem: "npm", name, version: v.version, dev: !!v.dev, integrity: v.integrity || "", source: "package-lock", depth });
-        if (v && v.dependencies) walk(v.dependencies, depth + 1);
-      }
-    };
-    walk(json.dependencies, 1);
-  }
-  return dedupe(out);
-}
-
-// yarn.lock selector → the REAL package name. Handles classic `name@range`, `@scope/name@range`, the
-// `@npm:` protocol (`name@npm:range`), AND aliases (`react-is-18@npm:react-is@18.3.1` → react-is) —
-// yarn installs aliased majors in `react-is-18/` dirs whose package.json name is still "react-is", so
-// the lockfile must resolve to that real name or drift/vuln checks miss the aliased versions.
-export function yarnSelectorName(sel) {
-  const s = String(sel || "").trim().replace(/^"|"$/g, "");
-  const npm = s.indexOf("@npm:");
-  if (npm >= 0) {
-    const after = s.slice(npm + 5); // text after "@npm:" — either "realname@range" (alias) or just "range"
-    if (/^[a-z@]/i.test(after)) { // starts with a letter/scope → it's the real package name
-      const at = after.startsWith("@") ? after.indexOf("@", 1) : after.indexOf("@");
-      return at > 0 ? after.slice(0, at) : after;
-    }
-    return s.slice(0, npm); // "range" only → the real name is before @npm:
-  }
-  const at = s.lastIndexOf("@"); // classic name@range ; leading @ of a scope is index 0, ignored
-  return at > 0 ? s.slice(0, at) : "";
-}
-
-// yarn.lock (classic v1 format): `"name@^1.0.0", "name@~1.2":\n  version "1.2.3"`
-export function parseYarnLock(text) {
-  const out = [];
-  const re = /^((?:"[^\n]*")|(?:[^\s#"][^\n]*?)):\r?\n\s+version\s+"([^"]+)"/gm; // greedy quote span — selector lists like "a@^1", "a@~2": keep the full line
-  for (const m of String(text || "").matchAll(re)) {
-    const name = yarnSelectorName(m[1].split(",")[0]);
-    if (name) out.push({ ecosystem: "npm", name, version: m[2], dev: false, integrity: "", source: "yarn-lock" });
-  }
-  return dedupe(out);
-}
-
-// requirements.txt: pins that carry a concrete version — exact `==`/`===` AND compatible-release `~=`
-// (`~=1.26.8` floors at 1.26.8 within the 1.26.* series, a solid check target). Loose `>=`/`>`/`<`
-// have no single version, so they're skipped (unknown-installed, not a false pin).
-export function parseRequirements(text) {
-  const out = [];
-  for (const raw of String(text || "").split(/\r?\n/)) {
-    const line = raw.replace(/(^|\s)#.*$/, "").trim();
-    if (!line || line.startsWith("-")) continue;
-    const m = line.match(/^([A-Za-z0-9][\w.-]*)\s*(===?|~=)\s*([\w.!+*-]+)/);
-    if (m) out.push({ ecosystem: "PyPI", name: pep503(m[1]), version: String(m[3]).replace(/\.\*$/, ""), dev: false, integrity: "", source: "requirements" });
-  }
-  return dedupe(out);
-}
-
-// A repo's virtualenv site-packages *.dist-info = the ACTUALLY-installed Python versions (the PyPI
-// equivalent of node_modules). Directory names are "<name>-<version>.dist-info". Windows Lib\ + posix lib\pythonX\.
-export function collectVenvPackages(repoPath, { readdir = readdirSync } = {}) {
-  const out = [];
-  for (const venv of [".venv", "venv", "env"]) {
-    const roots = [join(repoPath, venv, "Lib", "site-packages")]; // Windows layout
-    try { for (const d of readdir(join(repoPath, venv, "lib"))) if (/^python/i.test(String(d))) roots.push(join(repoPath, venv, "lib", String(d), "site-packages")); } catch { /* posix layout absent */ }
-    for (const sp of roots) {
-      let entries;
-      try { entries = readdir(sp); } catch { continue; }
-      for (const e of entries) {
-        const m = String(e).match(/^(.+?)-(\d[\w.!+-]*)\.dist-info$/);
-        if (m) out.push({ ecosystem: "PyPI", name: pep503(m[1]), version: m[2], dev: false, integrity: "", source: "venv" });
-      }
-    }
-  }
-  return dedupe(out);
-}
-
-// poetry.lock / uv.lock — same TOML shape: [[package]] blocks with name/version lines
-export function parseTomlLockPackages(text, source) {
-  const out = [];
-  let name = "", inPkg = false;
-  for (const raw of String(text || "").split(/\r?\n/)) {
-    const line = raw.trim();
-    if (/^\[\[package\]\]$/.test(line)) { inPkg = true; name = ""; continue; }
-    if (/^\[/.test(line)) { inPkg = false; continue; } // any other table ends the package header block
-    if (!inPkg) continue;
-    let m = line.match(/^name\s*=\s*"([^"]+)"/);
-    if (m) { name = m[1]; continue; }
-    m = line.match(/^version\s*=\s*"([^"]+)"/);
-    if (m && name) { out.push({ ecosystem: "PyPI", name: pep503(name), version: m[1], dev: false, integrity: "", source }); name = ""; }
-  }
-  return dedupe(out);
-}
-
-// Pipfile.lock: JSON { default: { name: {version:"==1.2.3"} }, develop: {…} }
-export function parsePipfileLock(json) {
-  const out = [];
-  for (const [section, dev] of [["default", false], ["develop", true]]) {
-    for (const [name, v] of Object.entries((json && json[section]) || {})) {
-      const ver = String((v && v.version) || "").replace(/^==/, "");
-      if (ver) out.push({ ecosystem: "PyPI", name: pep503(name), version: ver, dev, integrity: "", source: "pipfile-lock" });
-    }
-  }
-  return dedupe(out);
-}
-
-// go.sum: "module v1.2.3 h1:hash" (skip /go.mod hash lines). OSV Go versions have no leading v.
-export function parseGoSum(text) {
-  const out = [];
-  for (const raw of String(text || "").split(/\r?\n/)) {
-    const m = raw.trim().match(/^(\S+)\s+v([\w.+-]+?)(\/go\.mod)?\s+h1:/);
-    if (m && !m[3]) out.push({ ecosystem: "Go", name: m[1], version: m[2], dev: false, integrity: "", source: "go-sum" });
-  }
-  return dedupe(out);
-}
-
-// go.mod require versions — the fallback when there is no go.sum (fresh checkout / `go mod download`
-// not run). Pseudo-versions (v0.0.0-<ts>-<commit>) won't match OSV cleanly, but exact tags do; go.sum
-// (when present) supersedes these via dedupe. Leading `v` stripped to match OSV's Go versions.
-export function parseGoModPackages(text) {
-  return dedupe(parseGoMod(text).requires.map((r) => ({ ecosystem: "Go", name: r.path, version: String(r.version).replace(/^v/, ""), dev: !!r.indirect, integrity: "", source: "go-mod" })));
-}
-
-// Top-level node_modules walk (incl. @scopes): the ground truth of what is REALLY on disk.
-function walkNodeModules(repoPath, { readJsonFile = readJson, readdir = readdirSync } = {}) {
-  const out = [];
-  const nm = join(repoPath, "node_modules");
-  const readPkg = (dir, name) => {
-    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 = readdir(nm); } catch { return out; }
-  for (const e of entries) {
-    if (e.startsWith(".")) continue;
-    if (e.startsWith("@")) {
-      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);
-  }
-  return out;
-}
-
-const readText = (p) => { try { return readFileSync(p, "utf8"); } catch { return null; } };
-const readJson = (p) => { try { return JSON.parse(readFileSync(p, "utf8")); } catch { return null; } };
-
-const SUBPROJECT_SKIP = new Set([".git", ".idea", ".vscode", ".venv", "venv", "env", "node_modules", "vendor", "dist", "build", "coverage", "__pycache__", ".tox", "testdata"]);
-
-function projectDirs(boundary) {
-  const dirs = boundary.root ? [boundary.root] : [];
-  let entries = [];
-  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;
-    const resolved = boundary.resolve(e.name);
-    if (resolved.ok) dirs.push(resolved.path);
-    if (dirs.length >= 101) break;
-  }
-  return dirs;
-}
-
-function collectReqFiles(dir, readdir = readdirSync) {
-  const reqFiles = [];
-  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 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(boundedJson(join(dir, "package-lock.json")) || {});
-    lock.push(...lockHere);
-    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, { 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(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(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 = 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
-  // legitimately appears at SEVERAL versions in a lockfile (yarn/npm nest transitive duplicates), so
-  // track the FULL SET of locked versions per name. "Drift" = the installed version matches NONE of
-  // them — the old code compared against ONE arbitrarily-picked entry, which faked drift (a top-level
-  // @babel/code-frame@7.29.7 flagged against a nested 8.0.0 that is ALSO legitimately locked+installed).
-  const locked = new Map();       // name -> representative entry (hoisted/lowest-depth) = the version source
-  const lockedVers = new Map();   // name -> Set(every locked version)
-  for (const p of [...yarn, ...lock]) {
-    const prev = locked.get(p.name);
-    if (!prev || (p.depth || 1) < (prev.depth || 1)) locked.set(p.name, p); // strictly-lower depth = hoisted
-    (lockedVers.get(p.name) || lockedVers.set(p.name, new Set()).get(p.name)).add(p.version);
-  }
-  const merged = [...locked.values()];
-  const drift = [];
-  for (const d of disk) {
-    const vers = lockedVers.get(d.name);
-    if (!vers) merged.push(d);
-    else if (!vers.has(d.version)) drift.push({ name: d.name, locked: locked.get(d.name).version, installed: d.version });
-  }
-  const jvmRust = collectJvmRustInstalled(repoPath);
-  // The earlier fast path covers roots and immediate services. Complete the tracked repository
-  // universe so deeply nested Python/Go services are not silently omitted from advisory coverage.
-  const repositoryFiles = listRepoFiles(repoPath);
-  const allPython = repositoryFiles.flatMap((file) => {
-    const text = readRepoText(boundary, file);
-    if (/(^|\/)requirements[\w.-]*\.(?:txt|in)$/i.test(file) || /(^|\/)requirements\/[^/]+\.(?:txt|in)$/i.test(file)) return parseRequirements(text || "");
-    if (/(^|\/)poetry\.lock$/i.test(file)) return parseTomlLockPackages(text || "", "poetry-lock");
-    if (/(^|\/)uv\.lock$/i.test(file)) return parseTomlLockPackages(text || "", "uv-lock");
-    if (/(^|\/)Pipfile\.lock$/i.test(file)) { try { return parsePipfileLock(JSON.parse(text)); } catch { return []; } }
-    return [];
-  });
-  const allGo = repositoryFiles.flatMap((file) => {
-    const text = readRepoText(boundary, file) || "";
-    if (/(^|\/)go\.sum$/i.test(file)) return parseGoSum(text);
-    if (/(^|\/)go\.mod$/i.test(file)) return parseGoModPackages(text);
-    return [];
-  });
-  return { installed: dedupe([...merged, ...py, ...go, ...allPython, ...allGo, ...jvmRust]), drift };
-}

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

@@ -1,121 +0,0 @@
-import { readFileSync, readdirSync, existsSync, statSync, openSync, readSync, closeSync } from "node:fs";
-import { join, relative } from "node:path";
-import { MALWARE_ALLOWLIST, classifyPythonPth } from "./registry-sig.js";
-
-const normPath = (p) => String(p || "").replace(/\\/g, "/").replace(/\/+$/, "");
-const existingDir = (p) => {
-  try { return p && existsSync(p) && statSync(p).isDirectory(); } catch { return false; }
-};
-
-const PY_PTH_RE = /\.pth$/i;
-const BINARY_CANDIDATE_RE = /\.(exe|dll|dylib|so|node|bin)$/i;
-const BINARY_SUSPICIOUS_NAME_RE = /(^|[\\/])(postinstall|install|setup|update|loader|payload|helper|agent|service|runner)(\.[^\\/]+)?$/i;
-const NATIVE_SCRIPT_RE = /\b(node-gyp|node-pre-gyp|prebuild|node-gyp-build|cmake-js|cmake|make|napi|neon|cargo|go\s+build)\b/i;
-const NATIVE_DEP_RE = /^(node-addon-api|bindings|nan|prebuild-install|node-gyp|node-gyp-build|node-pre-gyp|@mapbox\/node-pre-gyp|cmake-js)$/i;
-const KNOWN_BINARY_PKG_RE = /^(?:@esbuild\/|@swc\/|@rollup\/rollup-|@img\/|@parcel\/watcher|esbuild$|sharp$|electron$|playwright$|@playwright\/|puppeteer$|cypress$|sass-embedded$|lightningcss$|tree-sitter$|tree-sitter-wasms$|better-sqlite3$|sqlite3$|bcrypt$|fsevents$|re2$|canvas$|workerd$)/i;
-const BUNDLED_BINARY_RULE = {
-  key: "bundled-binary",
-  severity: "medium",
-  nearZeroFp: false,
-  noisy: true,
-  what: "bundled executable/native binary without native-build package metadata",
-};
-
-function readJsonFile(file) {
-  try { return JSON.parse(readFileSync(file, "utf8")); } catch { return null; }
-}
-
-function hasNativeBuildHint(dir, pkgJson) {
-  const pj = pkgJson || {};
-  if (pj.gypfile || pj.binary || pj.os || pj.cpu) return true;
-  if (existingDir(join(dir, "prebuilds")) || existsSync(join(dir, "binding.gyp"))) return true;
-  const scriptText = Object.values(pj.scripts || {}).join("\n");
-  if (NATIVE_SCRIPT_RE.test(scriptText)) return true;
-  const deps = { ...(pj.dependencies || {}), ...(pj.optionalDependencies || {}), ...(pj.devDependencies || {}) };
-  return Object.keys(deps).some((name) => NATIVE_DEP_RE.test(name));
-}
-
-function binaryMagic(file) {
-  let fd = null;
-  try {
-    fd = openSync(file, "r");
-    const b = Buffer.alloc(8);
-    const n = readSync(fd, b, 0, b.length, 0);
-    if (n >= 2 && b[0] === 0x4d && b[1] === 0x5a) return "PE";
-    if (n >= 4 && b[0] === 0x7f && b[1] === 0x45 && b[2] === 0x4c && b[3] === 0x46) return "ELF";
-    if (n >= 4) {
-      const hex = b.subarray(0, 4).toString("hex");
-      if (["feedface", "feedfacf", "cefaedfe", "cffaedfe", "cafebabe", "cafebabf"].includes(hex)) return "Mach-O";
-    }
-  } catch { /* not readable */ }
-  finally { if (fd != null) { try { closeSync(fd); } catch { /* ignore */ } } }
-  return "";
-}
-
-function shouldSkipMetaPath(rel) {
-  const p = normPath(rel).toLowerCase();
-  return /(^|\/)(node_modules|\.git|docs?|documentation|test|tests|__tests__|fixtures?|examples?|coverage|dist-types)(\/|$)/.test(p) || /\.(map|md|mdx|markdown|rst|txt|d\.ts)$/i.test(p);
-}
-
-function binaryArtifactSweep(pkgDirs, capFiles = 12000) {
-  const hits = [];
-  let seen = 0;
-  for (const { pkg, dir } of pkgDirs) {
-    if (seen >= capFiles) break;
-    if (MALWARE_ALLOWLIST.has(pkg) || KNOWN_BINARY_PKG_RE.test(pkg)) continue;
-    const pj = readJsonFile(join(dir, "package.json")) || {};
-    if (hasNativeBuildHint(dir, pj)) continue;
-    const stack = [dir];
-    while (stack.length && seen < capFiles) {
-      const cur = stack.pop();
-      let entries = [];
-      try { entries = readdirSync(cur, { withFileTypes: true }); } catch { continue; }
-      for (const e of entries) {
-        const full = join(cur, e.name);
-        const rel = relative(dir, full);
-        if (shouldSkipMetaPath(rel)) continue;
-        if (e.isDirectory()) { stack.push(full); continue; }
-        if (!e.isFile()) continue;
-        seen++;
-        if (!BINARY_CANDIDATE_RE.test(e.name) && !BINARY_SUSPICIOUS_NAME_RE.test(full)) continue;
-        let st; try { st = statSync(full); } catch { continue; }
-        if (!st.size || st.size > 80_000_000) continue;
-        const kind = binaryMagic(full);
-        if (!kind) continue;
-        hits.push({
-          pkg,
-          file: full,
-          line: 0,
-          text: `${kind} binary ${normPath(rel)} in package with no native-build metadata`,
-          rule: BUNDLED_BINARY_RULE,
-        });
-        break;
-      }
-    }
-  }
-  return hits;
-}
-
-function pythonPthSweep(contentRoots) {
-  const hits = [];
-  for (const root of contentRoots) {
-    if (root.kind !== "PyPI") continue;
-    let entries = [];
-    try { entries = readdirSync(root.root, { withFileTypes: true }); } catch { continue; }
-    for (const e of entries) {
-      if (!e.isFile() || !PY_PTH_RE.test(e.name)) continue;
-      const file = join(root.root, e.name);
-      let text = "";
-      try { text = readFileSync(file, "utf8"); } catch { continue; }
-      const pkg = root.pathToPkg(file) || e.name.replace(PY_PTH_RE, "");
-      for (const sig of classifyPythonPth(text)) {
-        hits.push({ pkg, file, line: sig.line || 0, text: sig.snippet || "", rule: sig });
-      }
-    }
-  }
-  return hits;
-}
-
-export function fileHeuristicSweep(contentRoots, pkgDirs) {
-  return [...pythonPthSweep(contentRoots), ...binaryArtifactSweep(pkgDirs)];
-}

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

@@ -1,134 +0,0 @@
-// 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 INSTALL_SCRIPT_HOOKS = ["preinstall", "install", "postinstall"];
-
-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 installScriptSnippet(scripts = {}) {
-  for (const hook of INSTALL_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 (a license-header scheme reference on LICENSE line 5 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 +0,0 @@
-// 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";