Bumblebee: Best Endpoint Inventory CLI Tools for DevSecOps

What Is Bumblebee?

Bumblebee is a read-only endpoint inventory CLI tool built by Perplexity AI for macOS and Linux developer machines, and it is one of the best Endpoint Inventory CLI Tools for DevSecOps teams and incident responders. It scans local lockfiles, package metadata, extension manifests, and supported MCP configs to answer a specific supply-chain question: which developer endpoints match a named package or version right now. The repo ships with a built-in selftest that reports 2 findings in 1 ms, which gives you a fast sanity check before rolling it into a fleet job.

Quick Overview

Who Should Use Bumblebee?

• Incident responders who need to confirm whether a named advisory maps to live developer endpoints without waiting on an EDR query or a full SBOM rebuild.
• Platform and DevOps teams running recurring scans across ~/code, ~/src, or managed project roots and wanting structured inventory in NDJSON.
• Security engineers who need exact package/version matches from lockfiles, installed metadata, and extension manifests, not guessed results from process telemetry.
• Fleet admins who want a one-shot scanner they can schedule with cron, launchd, systemd, or MDM and then ship to a collector.

Not ideal for:

• Teams that want interactive endpoint query language access like SQL over live machine state.
• Workflows that depend on runtime process tracing, network telemetry, or memory inspection.
• Audits that require source-file parsing or package-manager execution such as npm ls, pip show, or go list.

Key Features of Bumblebee

• Read-only filesystem inventory — Bumblebee only reads lockfiles, package-manager metadata, extension manifests, and supported MCP JSON configs. It does not execute package managers, and it avoids source-file reads, which keeps scans deterministic and reduces endpoint risk.
• Three scan profiles — baseline, project, and deep let you tune breadth versus cadence. baseline covers common global and user roots, project targets known workspaces, and deep walks explicit roots for incident response or campaign checks.
• Wide ecosystem coverage — The scanner emits normalized records for npm, PyPI, Go modules, RubyGems, Composer, MCP, editor extensions, and browser extensions. That makes it useful when a developer endpoint mixes Node, Python, Go, Ruby, and browser add-ons in the same home directory.
• NDJSON output model — Each record is line-delimited JSON, which makes it easy to stream into jq, object storage, a log pipeline, or a receiver that maintains current state. Bumblebee also emits a terminal scan_summary record so downstream systems can decide whether a run is authoritative.
• Exposure catalog matching — When you provide an exposure catalog, Bumblebee flags exact matches against package name and version metadata. That is a tighter response loop than broad vulnerability scanning because responders already know what they are looking for.
• Versioned, traceable builds — The binary can stamp version, VCS revision, build time, and Go runtime details. That matters when you need to tie a finding back to a specific build that produced it.
• MCP config parsing with privacy controls — Bumblebee parses MCP host configs to inventory servers, but it does not emit values from env blocks. That design avoids leaking credentials while still extracting the metadata needed for exposure checks.

Bumblebee vs Alternatives

Pick OpenTrace instead of Bumblebee when you need to correlate the exposure with runtime telemetry, logs, or traces after the fact. If you are managing device identity and trust boundaries for a larger fleet, MachineAuth pairs well with Bumblebee because the scanner’s records already carry endpoint identifiers and can be routed by device. Use djevops when you want to automate the rollout of the scanner itself across developer machines.

How Bumblebee Works

Bumblebee works by walking approved filesystem roots and reading the metadata that package managers, editors, browsers, and MCP clients already left on disk. Its core abstraction is a normalized component record that includes ecosystem, package identity, version, source type, root kind, profile, and endpoint metadata, all serialized as NDJSON for streaming consumption.

The architecture is intentionally narrow. Bumblebee is a single static binary written in Go 1.25+ with zero non-stdlib dependencies, so the runtime footprint stays small and the deployment surface stays predictable. Instead of calling package-manager CLIs, it reads canonical artifacts such as package-lock.json, pnpm-lock.yaml, yarn.lock, go.sum, Gemfile.lock, composer.lock, extension manifests, and supported MCP JSON configs; that avoids side effects and keeps scans safe to run on sensitive developer laptops.

The command-line model is one-shot: you invoke a scan, it produces records, and it exits. That fits cron, launchd, systemd, and MDM-driven jobs better than a resident agent, and it lets the receiver decide when a scan is current based on the final scan_summary record and the per-root root_kind labels.

# getting started example
bumblebee scan --profile deep \
  --root "$HOME" \
  --exposure-catalog ./catalog.json \
  --findings-only

The command above performs an on-demand sweep of the home directory, compares discovered package metadata against a local exposure catalog, and suppresses non-matching package records. Expect NDJSON findings on stdout and diagnostics on stderr, then a summary record that downstream tooling can use to mark the run complete.

Pros and Cons of Bumblebee

Pros:

• Read-only by design — no package-manager execution and no source-file parsing, which reduces blast radius on developer endpoints.
• Strong fit for supply-chain response — it answers the exact question responders ask after an advisory drops: where is the affected package or version present right now.
• Deterministic output — NDJSON records are easy to ingest into log pipelines, object storage, or a rules engine.
• Useful profile split — baseline, project, and deep let you separate lightweight recurring inventory from heavyweight incident scans.
• Good cross-ecosystem coverage — npm, PyPI, Go, RubyGems, Composer, editor extensions, browser extensions, and MCP configs all land in one normalized model.
• Traceable builds — version stamping and runtime details make it easier to audit what binary produced a given record set.

Cons:

• Not a general endpoint sensor — Bumblebee does not provide live process, network, or memory visibility.
• No interactive query layer — you cannot ask ad hoc SQL-style questions against endpoints the way you can with some fleet tools.
• Coverage is intentionally file-based — if an environment stores dependencies outside the listed manifests or metadata files, Bumblebee will not infer them.
• MCP support is partial in v0.1 — non-JSON configs such as Codex config.toml and Continue YAML are not parsed yet.
• Home-directory scanning is restricted in lighter profiles — baseline and project refuse bare-home roots, so you must use deep for broad incident sweeps.

Getting Started with Bumblebee

# Install the latest tagged release.
go install github.com/perplexityai/bumblebee/cmd/bumblebee@latest

# Sanity-check the binary against embedded fixtures.
bumblebee selftest

# Run a baseline inventory and save NDJSON output.
bumblebee scan --profile baseline > inventory.ndjson

If you need to pin a build for repeatability, install a specific tag such as @v0.1.1 or compile from a checkout with go build. The selftest is useful before fleet rollout because it verifies the binary still detects the fake fixtures it ships with, and the baseline scan gives you a quick first inventory without touching broad roots.

Verdict

Bumblebee is the strongest option for read-only supply-chain exposure checks on developer endpoints when you need exact on-disk metadata and cannot afford package-manager execution. Its best strength is deterministic, profile-based inventory with NDJSON output; its main caveat is that it is not a live endpoint sensor. If your workflow is incident response or fleet hygiene, recommend it.