Inspiration

Supply-chain attacks on npm and PyPI keep getting faster. A compromised maintainer account publishes a bad version, and within hours it's in thousands of lockfiles and CI runs. Advisory feeds tell you a package is bad. They don't tell you whether your repo resolved that exact version, which CI runs installed it, or whether the upgrade will break your build. That last part is why security bumps sit unmerged for weeks. We wanted something that takes you from disclosure to a fix you've already seen pass your checks, in minutes.

What it does

Firebreak watches your GitHub repos' lockfiles and fixes vulnerable dependencies for you.

  • Inventory: reads package-lock.json, pnpm-lock.yaml, yarn.lock, bun.lock, uv.lock and pinned requirements.txt, plus the GitHub Actions your workflows use.
  • Live wire: every 10 minutes, each version you resolve is checked against OSV, including MAL- malware entries. Fresh security news is pulled from You.com, and a model extracts the named packages and versions as early warnings, often before an advisory exists.
  • Exposure: shows where each affected package sits (direct or transitive, and in which lockfile). For malicious releases, it lists the CI runs that installed it since disclosure and the workflow secrets you should rotate.
  • Fix plan: picks one target version that clears every known advisory for that package. That's an upgrade, a pin back below the first bad release, or an override for transitive dependencies. For Expo apps, bumps stay inside what your Expo SDK supports.
  • Fix loop: in an isolated Daytona sandbox it clones, patches, installs with lifecycle scripts disabled, proves the lockfile no longer resolves a bad version, and runs your type checks, build and tests. If something breaks, Codex repairs the code, with Clonvo as a fallback, for up to 3 rounds. Then the lockfile and checks run again from scratch.
  • PR: only after a passing run, and only when you click, Firebreak opens a pull request. Its body is a receipt: sources, the lockfile check, each attempt and the agent's notes. When it can, it also serves a live preview of the patched app.

Runs share what they learn through OpenCrawl. Before starting, a run reads notes earlier runs left about the same repo and packages, and when it finishes it posts what happened.

How we built it

  • Backend: a single Cloudflare Worker running Hono, with D1 for records and one FixRun Durable Object per hotfix. Each run advances one phase per alarm and streams its logs to the browser over a WebSocket.
  • Frontend: a Vite + React SPA (TanStack Router and Query, Tailwind v4), served from the same Worker. It shows a live pipeline graph of every step in a run.
  • Sandboxes: Daytona, for cloning, installing, testing and previewing untrusted code.
  • Data and agents: OSV for advisories; You.com for security news and migration notes; Clonvo (Claude Haiku for extraction, Sonnet for repair); Codex CLI as the in-sandbox repair agent; OpenCrawl for shared memory between runs.
  • Version logic: our own semver and PEP 440 range handling for choosing safe targets, covered by unit tests.

Challenges we ran into

  • Keeping the sandbox safe. The code we're fixing is untrusted. The sandbox gets no secrets, the GitHub token is removed from the git remote right after cloning, installs never run lifecycle scripts, and agent tokens are masked in every log line.
  • Trusting the agent's output. An AI fix that "looks right" isn't enough. We re-run the lockfile check and the full test suite after every agent change, so a bad edit can never turn into a PR.
  • Long jobs on serverless. A fix run takes minutes, so we split it into phases driven by Durable Object alarms. That way a run survives restarts and every step is visible.
  • Real-world repos are messy. Monorepos, Expo apps whose versions are pinned by the SDK, and workspaces where the first package isn't a web app at all (our preview once tried to serve a Telegram bot). Each of these needed specific handling.

Accomplishments that we're proud of

  • The full pipeline works end to end on real repos, from detection through a sandboxed fix, a passing test run and a ready-to-open PR.
  • Firebreak never opens a PR without a passing run and a human click.
  • The PR receipt shows exactly what was checked and why the fix is safe, so a reviewer can merge it with confidence.

What we learned

  • Most of the work in a dependency fix is verification. Choosing the new version is the easy part.
  • Agents get much more useful when you give them a tight loop: a concrete failing check, a sandbox, and a way to verify independently afterwards.
  • Lockfile formats differ more than you'd expect, even across versions of the same package manager.

What's next for Firebreak

  • Access control and per-team installs through a GitHub App, instead of a single personal token.
  • More ecosystems: Cargo, Go modules and Maven.
  • Notifications to Slack and email when a malicious release hits a repo you watch.
  • Letting OpenCrawl notes from past runs choose the repair strategy, not just inform it.

Built With

  • claude
  • clonvo
  • cloudflare-d1
  • cloudflare-workers
  • codex
  • daytona
  • durable-objects
  • github-actions
  • github-api
  • hono
  • npm
  • opencrawl
  • osv
  • react
  • tailwindcss
  • tanstack-query
  • tanstack-router
  • typescript
  • vite
  • websockets
  • you.com
Share this project:

Updates

Submission history