> ## Documentation Index
> Fetch the complete documentation index at: https://zeropath.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Supply Chain Intel

> Find risky npm and PyPI versions in your repositories and check dependency changes before merging on GitHub.

Use Supply Chain Intel to see whether a risky npm or PyPI package version is
already in a repository or is being introduced in a GitHub pull request. If
your deployment has Supply Chain Intel and you have access to repositories,
open **Supply chain → Intel**. The **Overview** surfaces exposure, campaigns,
recent detections, and registry changes that affect versions you use.

For a branch's full dependency inventory, known vulnerabilities, or
[AI components](https://zeropath.com/docs/sca/ai-inventory.md), open the repository's **Inventory** tab.
See [Software Composition Analysis](https://zeropath.com/docs/sca/overview.md) for the scanning workflow.

## Find and address exposure

1. Open **Exposure** and look for the version you need to investigate. The
   main list groups versions flagged for malware or a security-related
   registry withdrawal. Choose the repositories you need to review.
2. Use **Impact** to see where a matching version appears in indexed scans or
   open pull requests. Check the version, branch or PR, and evidence link.
   Select **What to do** on the exposure to open the package page for that version.
3. Replace or remove the affected version, regenerate and commit the lockfile,
   and run a new [dependency scan](https://zeropath.com/docs/sca/overview.md#how-dependency-data-gets-in)
   on the affected branch. Recheck the inventory and the exposure after the
   new scan is indexed.

Use **Detections** to investigate individual signals from ZeroPath, advisory
sources, and package registries. Review the source and evidence before acting
on an unconfirmed signal. Use **Changes** to see registry events for versions
found on indexed default branches or newly introduced in open PRs.

Intel matches versions in the repositories you can view using indexed
dependency scans and pull request checks. If an expected match is missing,
check the branch, repository scope, and [scan coverage](https://zeropath.com/docs/sca/coverage.md).

You can subscribe to
[`SUPPLY_CHAIN_MALWARE_DETECTED`](https://zeropath.com/docs/webhook/introduction#supported-event-types)
to receive malware exposure events in your own tooling.

## Investigate a malware campaign

Open **Campaigns** to see related packages and versions grouped into known
malware campaigns. The list shows whether affected versions appear in
repositories you can view or triggered a failed Supply Chain Intel check
on a pull request.

1. Open a campaign and review **Your exposure**, when shown, for affected
   repositories and links to PR check evidence.
2. Review the campaign's packages or versions. Open a package and select the
   affected version to see the evidence and remediation guidance.
3. Prioritize versions on active branches and review flagged PRs before
   merging.

Use `SUPPLY_CHAIN_CAMPAIGN_VALIDATED` for newly validated ZeroPath campaigns
and `SUPPLY_CHAIN_CAMPAIGN_IMPACT` for campaign versions found in default-branch
scans. See [webhook setup](https://zeropath.com/docs/webhook/introduction.md#configuring-webhooks).

## Look up a package version

In **Intel**, enter a package and version in **Package or advisory ID** and
press Enter. For example, search for `npm:lodash@4.17.21` or
`pypi:requests@2.32.3`. Confirm the version in the package header before
reading the verdict. Open **Analysis** or **Advisories** to review the evidence
and check **Way out** on the **Overview** when it's available. Open **Your usage**
to see the versions of the package found in your repositories and pull requests.

Search for a malware advisory ID to open **Impact**. Review **Where it is**
for repository and version matches, and use **Export CSV** to share those
rows when there are matches.

## Check dependency changes on GitHub

The **ZeroPath Supply Chain Intel** check evaluates newly introduced versions
in supported npm and PyPI dependency files. It runs alongside your regular
[PR scan](https://zeropath.com/docs/scanning/pr-scanning.md), so reviewers can see which package version
matched a policy rule before merging.

1. In the repository's pull request settings, enable **Pull Request Scanning**
   and **Post Check Status**. VCS checks must also be enabled for the repository.
2. In **Supply chain → Policy → Pull request check**, turn on **Check pull
   requests**. Turn on **Bot pull requests** to cover dependency updates
   from services such as Dependabot and Renovate.
3. Open or update a GitHub PR. Find the result in GitHub or under
   **Intel → Pull requests**. Open the check details to see the rule match
   and any dependency files the check could not resolve.
4. To enforce the result before merge, make the posted check name required
   in your GitHub ruleset or branch protection settings.

Supported lockfiles include `package-lock.json`, `npm-shrinkwrap.json`,
`pnpm-lock.yaml`, `yarn.lock`, `Pipfile.lock`, `poetry.lock`, and `uv.lock`.
When a supported manifest has no lockfile, the check can read versions
pinned in the manifest. Commit lockfiles to give the check the resolved
direct and transitive versions.

## Set a policy and review exceptions

Open **Supply chain → Policy → Rules** to choose an organization preset
(**Low noise**, **Default**, or **Strict**) and configure rules. Use
**Tag overrides** or **Repository overrides** to scope rules to a subset of
repositories. To change the policy, you need permission to edit the
organization's scanner settings.

| Action | Effect on the PR check |
| - | - |
| **Block** | Fails the check. |
| **Warn** | Reports the match. A check with only warnings uses the configured **Success** or **Neutral** conclusion. |
| **Monitor** | Records the match without changing the conclusion. |
| **Off** | Skips the rule. |

If multiple rules match a version, the strongest action among hits without
an applicable exception determines that version's result. Use
**Pull request check** to set how the check handles old intel and warnings.
Use **Internal sources** to identify your private package names or registries.

If you need to use a version the check flagged, follow the
[GitHub exception instructions](https://zeropath.com/docs/scanning/bot-commands.md#supply-chain-intel-check-exceptions).
The matching rules determine whether exceptions are allowed and whether they
require approval. Review requests, active exceptions, and expiry dates in
**Intel → Exceptions**.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.