limbo.watch

New in 0.1.0a17

Run it without limbo.watch

No feed at all, or a feed you build on your own CI. Same scan, same reports.

Which one?

  • Your runners can’t reach limbo.watch, or your policy says vulnerability data must come from systems you run: your own feed, of your own projects’ dependencies. One pipeline to copy; it’s complete after its first run, and scans then need almost no GitHub requests.
  • You want nothing to maintain: no feed. Add one option to the scan you already have and give it a read-only GitHub token.
  • limbo.watch is allowed: the limbo feed. Nothing to set up, and it covers about 67,000 repositories, not only your own dependencies’.

You can switch at any time: it’s one setting, --feed or LIMBOWATCH_FEED, and findings carry over between them.

Two ways, both new

Scans normally download the limbo feed: 11,017 advisories in limbo that limbo.watch’s tracker collects every day. Since release 0.1.0a17 a scan doesn’t need it. If your policy says vulnerability data must come from systems you run, or your runners can’t reach limbo.watch, pick one:

  • No feed. Nothing to set up. Each scan reads the published advisories of your dependencies’ source repositories on GitHub itself.
  • Your own feed. Run the same tracker limbo.watch runs, on your own CI, and point your scans at its output. Your feed’s data never passes through limbo.watch.
No feedYour own feedlimbo.watch’s feed
Set-upNoneA daily pipeline you copy into a repository or project of yoursNone
Advisory data fromGitHub, read by each scanYour tracker, on your CI, from GitHub, the CVE List, CVE Services and OSVlimbo.watch’s tracker
GitHub requests per scanOne per source repository of your dependencies0 to 4 in our tests, with a feed of your own dependenciesOnly for repositories the feed doesn’t watch
Not detectedDependencies with no known GitHub repository; duplicates; CVEs an advisory doesn’t citeYour dependencies with no GitHub repository are matched by name only—

Either way the scan, its reports, its issues and its exit codes are the same as with the limbo feed.

No feed: just the command line

# needs OSV-Scanner 2.7.1
pipx install limbowatch-cli==0.1.0a21
# a read-only GitHub token: 5,000 requests an hour instead of 60
export GITHUB_TOKEN=…
limbowatch scan . --feed none

For each dependency the scan finds its source repository, reads that repository’s published advisories, and keeps the ones scanners don’t see yet: not withdrawn, not in OSV. A read-only GitHub token is all it needs. In CI:

# GitHub Actions, Gitea, Forgejo
- uses: limbowatch/limbowatch-action@v0.1.0a21
  env:
    LIMBOWATCH_FEED: none

# GitLab CI: the component as usual,
# plus a CI/CD variable LIMBOWATCH_FEED = none

What it can’t do without a feed: a dependency whose source repository isn’t known is reported as not checked, with the reason, never dropped. Duplicates of reviewed advisories, and CVEs an advisory doesn’t cite, need the tracker’s history, so they aren’t detected. In our tests on four projects it missed no finding the limbo feed gave, and took 1.4 to 4 times as long (F-214).

Your own feed

The same tracker, on your CI, every day. It syncs GitHub’s reviewed advisories and the CVE List, polls the repositories it watches, and publishes a feed in the same format as limbo.watch’s: all.zip and watchlist.json, in OSV’s format. Two choices:

  • Focused (recommended for your own scans): only the source repositories of your own projects’ dependencies, listed again each run by limbowatch repos. Complete after its first run.
  • Popular: the release’s seed lists, about 67,000 repositories behind the most-used packages, like limbo.watch. About four weeks of daily runs to fill.

Host the feed wherever your scans can reach it: Pages, a branch of the same repository, or any static HTTPS server.

Build it from the command line

pipx install limbowatch-cli==0.1.0a21
# your dependencies' source repos (or: folders, SBOMs, --gitlab-group)
limbowatch repos --github-org acme --out repos.txt
# the tracker; --cve-list on the first run only: the CVE List's newest bulk export
limbowatch track --state state --seed repos.txt --only-seeds \
    --cve-list 2026-11-17_all_CVEs_at_midnight.zip.zip
limbowatch publish --state state --out site --feed-only
limbowatch scan . --feed site/feed

repos maps each dependency to its source repository the way scan does, sending package names, never files. Dependencies with no GitHub repository are listed at the end of repos.txt. The bulk export is optional; with it, the first run knows which CVEs name which advisories. Download the newest one from CVEProject/cvelistV5.

On GitHub Actions

  1. Copy limbo-feed.yml to .github/workflows/ in a repository of yours. An empty one is fine.
  2. Set repository variables: LIMBO_FEED_WATCH = focused, LIMBO_FEED_ORGS = your organizations, and LIMBO_FEED_PUBLISH = branch to keep the feed in a branch, or pages.
  3. Optional secrets: LIMBOWATCH_GITHUB_TOKEN for more GitHub requests, and LIMBOWATCH_SOURCE_TOKEN to list private repositories.
  4. Run it once by hand; it runs daily after that.

Simpler, with no image: limbo-feed-cli.yml uses no actions at all. It installs the CLI with pipx, runs the commands above, and keeps the feed in the limbo-feed branch (CLI only).

Scan jobs check the branch out and pass the directory:

# pin actions by commit, as your others
- uses: actions/checkout@v4
  with:
    repository: acme/limbo-feed
    ref: limbo-feed
    path: limbo-feed
- uses: limbowatch/limbowatch-action@v0.1.0a21
  env:
    LIMBOWATCH_FEED: limbo-feed/feed

In a public repository the workflow attests the feed; in a private one, only if your plan includes attestations there (F-218).

On GitLab CI

  1. Copy .gitlab-ci.yml into a project of yours and add a daily pipeline schedule.
  2. Add a masked CI/CD variable LIMBOWATCH_GITHUB_TOKEN: a fine-grained GitHub token with read access to public repositories. Without it GitHub allows 60 requests an hour.
  3. Set WATCH = focused and FOCUS_GROUPS = your groups; a group access token in LIMBOWATCH_SOURCE_TOKEN lists their private projects.
  4. Keep the package registry on: the tracker’s state lives there between runs, read and written with the job’s own token, on every tier (F-220).

The feed is served by GitLab Pages, at the domain under Deploy → Pages. Scans must reach it without signing in, so check Pages’ visibility under Settings → General. Then:

include:
  - component: $CI_SERVER_FQDN/limbowatch/limbowatch-component/limbowatch@0.1.0-alpha.21
# plus a CI/CD variable:
# LIMBOWATCH_FEED = https://<your Pages domain>/feed/

Simpler, with no Limbowatch image: .gitlab-ci.cli.yml runs in python:3.12, installs the CLI with pip and runs the same commands (CLI only).

What changes in the reports

  • They name the feed. The table’s header and the JSON’s feed say which feed was read; with no feed it’s null. The attribution, in reports and issues alike, says where the advisories came from.
  • No limbo.watch attestation check. It applies only to limbo.watch’s feed. Your feed lives inside your own trust boundary.
  • The same age check. A feed more than three days old gets a warning: your pipeline stopped running.
  • Holes are filled at scan time. A repository your feed doesn’t watch, or hasn’t checked in ten days, is read on GitHub during the scan.

What we measured

  • A focused feed of three projects’ 1,511 repositories: every finding the limbo feed gave, with 0 to 4 GitHub requests per scan instead of up to about 500 with limbo.watch’s feed, in 1.6 to 7.5 seconds (F-216).
  • Both pipelines in real CI, public and private: about 9 to 11 minutes for the first run, about a minute a day after that (F-218, F-220, F-221).
  • Scans against the self-built feeds gave the same findings as against limbo.watch, on our proof repository’s packages.