Airlock

A firewall between AI coding agents and dangerous actions.

Airlock blocks hallucinated/slopsquatted package installs, package execution, leaked secrets, destructive shell commands, and suspicious test changes before they ship. It works as a CLI, an MCP server, a Claude Code PreToolUse hook, a git pre-commit hook, and universal PATH shims for any agent or human using your shell.

npx airlock-cli demo

Airlock demo: AI agent wants to run this:

 BLOCK  npx fast-csv-helper init && rm -rf ~
  x Recursive force-delete targeting a root/home path (rm -rf on / ~ or $HOME).
  x [fast-csv-helper] Package "fast-csv-helper" does not exist on npm.

Stopped before anything executed.

AI coding assistants can hallucinate plausible package names. Security researchers call the attack pattern slopsquatting: attackers register names that models tend to invent, then wait for developers or agents to install them. See research from Cloud Security Alliance, Trend AI Security, and Socket.

Airlock is the seatbelt: let the agent move fast, but force the scary stuff through a deterministic check first.

Quick Start

# one-off package checks
npx airlock-cli check express
npx airlock-cli check requests -e pypi

# vet a whole command before an agent runs it
npx airlock-cli vet-command "npx fast-csv-helper init && rm -rf ~"

# run the full repo safety pass before saying "done"
npx airlock-cli audit

# see which protection layers are installed
npx airlock-cli doctor

Exit codes:

0: no blocking finding for the command
1: blocked package/command, leaked secret, or audit finding
2: usage error

Wire It Into Your Agent

npx airlock-cli init claude-code   # MCP + native PreToolUse hook
npx airlock-cli init codex         # MCP in ~/.codex/config.toml
npx airlock-cli init gemini        # MCP in ~/.gemini/settings.json
npx airlock-cli init cursor        # MCP in .cursor/mcp.json
npx airlock-cli init shell         # universal PATH shims
npx airlock-cli init git           # pre-commit secrets + test-change guard
npx airlock-cli init all

| Surface | Integration | What it protects | |---|---|---| | Claude Code | MCP + PreToolUse hook | Blocks dangerous Bash tool calls before execution | | Codex | MCP server | Gives Codex vet_package and vet_command tools | | Gemini CLI | MCP server | Gives Gemini vet_package and vet_command tools | | Cursor | MCP server | Gives Cursor vet_package and vet_command tools | | Any shell / any agent | PATH shims | Intercepts package managers at the process level | | Git | pre-commit hook | Blocks leaked secrets and suspicious staged test changes |

Claude Code hooks can return permissionDecision: "deny" for PreToolUse events, so Airlock can block a Bash command without relying on the model to remember a rule. Claude Code, Codex, Gemini CLI, and Cursor all support MCP server configuration; Airlock writes those config files for you.

Universal Shell Guard

For the wrapper-agnostic layer:

npx airlock-cli guard install
export PATH="$HOME/.airlock/shims:$PATH"

This installs shims for:

npm, npx, pnpm, yarn, bun, bunx, pip, pip3, pipx, uv, uvx, poetry, cargo, gem, bundle, bundler, go

Now these are vetted whether they are run by you, Claude Code, Codex, Gemini, Cursor, OpenCode, Roo, Cline, a random shell script, or anything else:

npm install express
npx create-next-app@latest app
pnpm dlx shadcn@latest init
uvx ruff check
pipx run black .
cargo add serde
gem install rails
go install github.com/gin-gonic/gin@latest

Remove shims:

npx airlock-cli guard uninstall

What Airlock Checks

Dependency and package-execution guard (npm, PyPI, crates.io, RubyGems, Go modules):

Package existence: nonexistent packages/modules -> block
Typosquat: expresss -> express
Mashup/slopsquat: lodash-utils, requests-helper
New + low adoption: recently published packages with weak adoption -> warn/block
Provenance: missing source repository or deprecated packages -> warn
Package executors: npx, npm exec, pnpm dlx, yarn dlx, bunx,

uvx, pipx run

Scaffold aliases: npm create vite maps to the actual create-vite

package before vetting

Manifest scan: package.json, requirements.txt, pyproject.toml,

Cargo.toml, Gemfile, go.mod

Destructive-command guard:

rm -rf /, rm -rf ~, rm --no-preserve-root -> block
fork bombs, dd/mkfs to devices, redirects to raw block devices -> block
git push --force, git reset --hard, git clean -f -> warn
DROP TABLE, TRUNCATE TABLE, curl ... | sh -> warn
package execution from URL/Git specs -> warn

Repo-audit guards:

airlock secrets blocks high-confidence GitHub/OpenAI/Anthropic/AWS/Slack

tokens and private keys

airlock diff --staged warns on suspicious test changes: removed assertions,

skipped tests, focused-only tests, or deleted test files

airlock audit runs dependency, secret, and test-change checks together

In Claude Code:

BLOCK -> deny
WARN -> ask
ALLOW -> silent

Project Policy

Private packages and team decisions belong in policy, not in CLI flags:

npx airlock-cli policy init

Creates .airlock.json:

{
  "allow": {
    "npm": ["@your-org/*"],
    "pypi": ["your-private-package"],
    "cargo": ["your-private-crate"],
    "rubygems": ["your-private-gem"],
    "go": ["github.com/your-org/*"]
  },
  "block": {
    "npm": ["known-bad-package"],
    "pypi": ["known-bad-package"],
    "cargo": ["known-bad-crate"],
    "rubygems": ["known-bad-gem"],
    "go": ["github.com/bad/*"]
  }
}

Policy files are discovered from the current directory upward, so a repo can carry its own allow/block rules.

GitHub Action

Use Airlock in CI before merging agent-generated changes:

name: Airlock

on: [pull_request]

jobs:
  airlock:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: cjaston/airlock@main
        with:
          path: "."

MCP Tools

Airlock exposes these MCP tools:

vet_package({ name, ecosystem, cwd? })
vet_command({ command, cwd? })
scan_project({ cwd? })
scan_secrets({ cwd? })
scan_diff({ cwd?, staged? })
audit_project({ cwd?, staged? })

Agents should call vet_command before shell commands that install packages, execute packages, delete files, rewrite git history, touch disks, or touch databases. Agents should call audit_project before finishing or committing code. If the result is BLOCK, do not run the command.

Privacy

No backend
No telemetry
Package names are looked up directly against public registry APIs
Registry facts are cached locally in ~/.airlock/cache
Disable cache for a run with AIRLOCK_NO_CACHE=1

npx airlock-cli cache status
npx airlock-cli cache clear

Build From Source

git clone https://github.com/cjaston/airlock.git
cd airlock
npm install
npm test
node dist/index.js demo

Requires Node 20+.

Acknowledgements

Built by Chris Jaston with AI-assisted development from OpenAI Codex. Airlock is an independent open-source project and is not an official OpenAI product or endorsement.

Roadmap

[x] npm + PyPI + crates.io + RubyGems + Go module checks
[x] typosquat + mashup/slopsquat heuristics
[x] npx/dlx/uvx/pipx package execution checks
[x] destructive-command guard
[x] MCP server (vet_package, vet_command)
[x] Claude Code PreToolUse hook
[x] universal PATH shims
[x] project policy file (.airlock.json)
[x] repo manifest scan
[x] secret-leak guard
[x] test-subversion detector
[x] git pre-commit hook
[ ] more ecosystems: maven, nuget, composer
[ ] signed policy bundles for teams

License

MIT

airlock