Dev Encyclopedia
ArticlesTools

Get notified when new content drops

No spam. Just new articles, tools, and updates straight to your inbox.

Dev Encyclopedia

A reference for builders

Content

  • Articles
  • Tools
  • Contact

Connect

  • support@devencyclopedia.com
  • RSS Feed

© 2026 Dev Encyclopedia

Privacy PolicyTermsDisclaimer
  1. Home
  2. /Blog
  3. /Bumblebee Tutorial: Scan Your Dev Machine for Supply Chain Risks
security11 min read

Bumblebee Tutorial: Scan Your Dev Machine for Supply Chain Risks

How to install and use Bumblebee, Perplexity's open-source scanner for npm, MCP configs, and extensions. Real commands, scan profiles, and incident response setup.

By Dev EncyclopediaPublished June 21, 2026
On this page

On this page

  • What Bumblebee Scans
  • Installing Bumblebee
  • The Three Scan Profiles
  • Running Your First Scan
  • Using an Exposure Catalog for Incident Response
  • Checking MCP Configs
  • Scheduling Regular Scans
  • What Bumblebee Doesn't Do
  • Frequently Asked Questions

Every time a supply chain attack hits, security teams ask: which dev machines have the compromised package installed? SBOMs cover production builds. EDR covers running processes. Neither checks the actual files sitting on a developer's laptop.

Perplexity open-sourced Bumblebee (May 22, 2026) to fill that gap: a small, read-only Go binary that inventories npm, pnpm, Yarn, Bun, PyPI, Go modules, RubyGems, Composer packages, plus MCP configs and editor/browser extensions. No install scripts, no network calls during scanning, no write operations.

DepScan checks a single package.json in the browser; Bumblebee checks your entire machine across 8 ecosystems. The same supply chain principles apply locally, not just in CI.

💡 TL;DR

Clone, build with Go, run bumblebee scan --profile baseline > inventory.ndjson. Pipe to jq or your SIEM. When a compromise drops, point an exposure catalog at it for instant fleet-wide triage.

What Bumblebee Scans

CategoryWhat it checksExample paths
npm/pnpm/Yarn/BunLockfiles and node_modules~/.npm, ~/code/**/package-lock.json
PyPIpip installs and virtualenvs~/.local/lib/python*, **/venv/
Go modulesgo.sum and module cache~/go/pkg/mod
RubyGemsGem installs~/.gem, **/Gemfile.lock
ComposerVendor directories**/composer.lock
MCP configsAI agent server configsmcp.json, claude_desktop_config.json, .claude.json
Editor extensionsVS Code, Cursor, Windsurf~/.vscode/extensions, ~/.cursor/extensions
Browser extensionsChromium and FirefoxChrome/Default/Extensions, .mozilla/firefox

All scans are read-only. Bumblebee never executes a package manager or runs install scripts, which sidesteps attacks that hide in preinstall/postinstall hooks.

Installing Bumblebee

  1. 1

    Clone and Build (requires Go 1.25+)

    bash
    git clone https://github.com/pplx-oss/bumblebee.git
    cd bumblebee
    go build -o bumblebee ./cmd/bumblebee
  2. 2

    Verify the Binary

    bash
    ./bumblebee --version

    You should see the version string and build commit. If not, confirm your Go version with go version (must be 1.25 or later).

  3. 3

    (Optional) Move to PATH

    bash
    sudo mv ./bumblebee /usr/local/bin/

ℹ Info

No install script that pipes to a shell. You build from source, which is intentional for a security tool: you can read the code before trusting the binary.

The Three Scan Profiles

ProfileWhat it scansBest for
baselineCommon global/user package roots, language toolchains, extensions, MCP configsDaily cron, routine inventory
projectTargeted sweep of specific dev directories (~/code, ~/src)Auditing work projects on demand
deepOperator-supplied roots including full home directoryActive incident response

⚠ Warning

baseline and project refuse bare-home roots. Only deep will walk them, since scanning an entire home directory is significantly more invasive and slower.

Running Your First Scan

  1. 1

    Run a Baseline Scan

    bash
    bumblebee scan --profile baseline > inventory.ndjson

    Output is NDJSON (one JSON record per line). Diagnostics go to stderr, inventory goes to stdout. This makes piping clean.

  2. 2

    Filter Output with jq

    Pull only npm packages:

    bash
    cat inventory.ndjson | jq -r 'select(.ecosystem == "npm") | .package'

    List all discovered MCP config file paths:

    bash
    cat inventory.ndjson | jq -r 'select(.ecosystem == "mcp") | .path'
  3. 3

    Count Packages by Ecosystem

    bash
    cat inventory.ndjson | jq -r '.ecosystem' | sort | uniq -c | sort -rn

    This gives you a quick breakdown of how many packages each ecosystem contributes to your machine's footprint. A typical active dev machine shows 500+ npm packages, a handful of Go modules, and 10-30 editor extensions.

Using an Exposure Catalog for Incident Response

When a new supply chain compromise drops, the first question is: are we affected? Bumblebee's exposure catalog feature turns that into a 5-second answer instead of a manual grep across every developer machine.

Create a JSON file describing the compromised packages:

json — advisory.json
{
  "schema_version": "1.0",
  "entries": [
    {
      "id": "ADV-2026-0042",
      "name": "colors-hijack",
      "ecosystem": "npm",
      "package": "colors",
      "versions": [">=1.4.1 <1.4.3"],
      "severity": "critical"
    },
    {
      "id": "ADV-2026-0043",
      "name": "faker-hijack",
      "ecosystem": "npm",
      "package": "faker",
      "versions": [">=6.6.6"],
      "severity": "high"
    }
  ]
}

Then run a targeted deep scan against it:

bash
bumblebee scan --profile deep --ecosystem npm --exposure-catalog advisory.json --findings-only

The --findings-only flag means you only see records that match the catalog. No match, no output. This turns "is anyone running the compromised version?" into a trivially scriptable check you can run across your fleet.

Checking MCP Configs

MCP (Model Context Protocol) configs define which external servers your AI coding tools connect to. After the ContextCrush incident in March 2026, this became a real attack surface: a malicious MCP server can exfiltrate code context, inject prompts, or pivot into your development environment.

Bumblebee checks these config files: mcp.json, .mcp.json, claude_desktop_config.json, mcp_config.json, mcp_settings.json, cline_mcp_settings.json, Gemini CLI/Code Assist settings, and ~/.claude.json.

bash
bumblebee scan --profile baseline --ecosystem mcp

This outputs every MCP server config found on the machine, with the server URL and transport type for each entry. You can then cross-reference against known compromised servers or your organization's allowlist.

For a quick browser-based check of a single config file without installing anything, use the MCPConfigCheck tool.

Scheduling Regular Scans

A one-off scan is useful during an incident. A daily scan turns Bumblebee into continuous inventory. Here's a crontab entry that runs at 2 AM every day:

bash — crontab -e
0 2 * * * /usr/local/bin/bumblebee scan --profile baseline > /var/log/bumblebee/inventory-$(date +\%Y-\%m-\%d).ndjson 2>&1

On macOS, launchd is more reliable than cron for scheduled tasks. Here's a plist that achieves the same thing:

xml — ~/Library/LaunchAgents/com.bumblebee.scan.plist
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN"
  "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
  <key>Label</key>
  <string>com.bumblebee.scan</string>
  <key>ProgramArguments</key>
  <array>
    <string>/usr/local/bin/bumblebee</string>
    <string>scan</string>
    <string>--profile</string>
    <string>baseline</string>
  </array>
  <key>StandardOutPath</key>
  <string>/var/log/bumblebee/inventory.ndjson</string>
  <key>StartCalendarInterval</key>
  <dict>
    <key>Hour</key>
    <integer>2</integer>
    <key>Minute</key>
    <integer>0</integer>
  </dict>
</dict>
</plist>

For security teams managing a fleet, forward these NDJSON files to a central log aggregator (Splunk, Elastic, or even a simple S3 bucket). When an advisory drops, you query your existing inventory instead of scanning every machine in real time.

What Bumblebee Doesn't Do

  • Windows support (macOS and Linux only currently)
  • Runtime behavior detection (it reads files, doesn't execute them)
  • SBOM replacement (covers dev endpoints, not production builds)
  • EDR replacement (reads on-disk state, doesn't monitor running processes)
  • Network analysis (doesn't check what packages do when executed)
  • Remediation (reports findings, doesn't auto-fix or quarantine)

Bumblebee fills the specific gap between SBOMs and EDR. It tells you what's on disk right now, not what ran or what shipped. Pair it with a VS Code extension audit for a more complete picture of your local attack surface.

Frequently Asked Questions

What does Bumblebee scan for?

Bumblebee inventories installed packages across 8 ecosystems (npm, pnpm, Yarn, Bun, PyPI, Go modules, RubyGems, Composer), MCP configs, and editor/browser extensions. It's read-only and never executes package managers or install scripts.

Is Bumblebee safe to run?

Yes. It's read-only by design and never executes install scripts or package managers. The binary makes no network calls during scanning. It's Apache 2.0 licensed and fully source-available, so you can audit the code before building.

What is the difference between Bumblebee and an SBOM?

SBOMs inventory your production build artifacts (what ships to users). Bumblebee inventories your developer machine (what's installed locally). They complement each other: an SBOM tells you what's in the container you deployed, while Bumblebee tells you what's sitting on every engineer's laptop right now.

How do I check my MCP configs for known compromises?

Run the following command to list all MCP server configs found on your machine:

bash
bumblebee scan --profile baseline --ecosystem mcp

For a browser-based check without installing anything, use the MCPConfigCheck tool. It validates a single config file against known-bad server patterns.

Does Bumblebee work on Windows?

Not currently. Bumblebee supports macOS and Linux. Windows support is tracked in the GitHub issues but has no release date yet. If you need Windows coverage, you can run it inside WSL2 to scan packages visible from the Linux filesystem.

Related Articles

security

GitHub Actions Security: 7 Misconfigurations to Avoid

The 7 GitHub Actions misconfigurations behind real supply chain attacks: weak GITHUB_TOKEN scope, pull_request_target, unpinned actions, script injection.

Jun 12, 2026·14 min read
security

WordPress CDN Supply Chain Attack 2026: What Happened and How to Check Your Site

The OptinMonster, TrustPulse, and PushEngage supply chain attack (June 2026) hit 1.2M sites. Here's exactly how it worked, how to check if you were compromised, and how to recover.

Jun 21, 2026·12 min read
security

How to Audit Your VS Code Extensions for Security

The GitHub breach happened through a VS Code extension. Here's how to check what you have installed and reduce your exposure in 10 minutes.

May 30, 2026·6 min read

On this page

  • What Bumblebee Scans
  • Installing Bumblebee
  • The Three Scan Profiles
  • Running Your First Scan
  • Using an Exposure Catalog for Incident Response
  • Checking MCP Configs
  • Scheduling Regular Scans
  • What Bumblebee Doesn't Do
  • Frequently Asked Questions
Advertisement