TL;DR
- The question: can I see, in one place, everything Claude Code can touch in a project on my Mac, switch each thing off, and trust that the page tells the truth?
- What I built: Airlock, a Mac app with one page per project and a switch for every file, command, site, database, key, SSH server and connector, plus a sealed Docker box for work I don’t trust.
- The result: 515 edge cases listed, 484 proven by a named test, 31 written down as limits; every “Claude can’t” line held when the real Claude Code ran under macOS’s sandbox.
- My take: the switches were the easy part. Making the page agree with what Claude Code really does took most of the five days.
When I ran Airlock’s read-only scan on my own Mac, it found 30 projects Claude Code has worked in, 524 allow rules, 48 hooks and helpers and 8 claude.ai connectors. I couldn’t answer a simple question: what can Claude reach in this folder right now? The answer is spread over five settings files, three MCP config locations, my shell’s variables and the logins on my Mac. So I built one page that answers it, and asked whether I could make that page honest.
#One page, three levels of protection

All screenshots come from the test home folder: fake secrets and sample projects, not my real Mac.
Open a project in Airlock and it reads the project and your Claude Code setup, then shows two lines at the top: Claude can (read code · edit files · run tests …) and Claude can’t (see 1 secret file · push · reach other sites from commands …). Below that, every item it found has a switch: secret files, commands (Allow, Ask or Block), sites, database connections, MCP servers and plugins, hooks, keys, SSH servers and claude.ai connectors. The same page exists for what applies everywhere and for Claude Desktop, and it updates while it’s open.


There are three levels of protection per project:
- Normal. The Claude you already use follows the switches. Airlock writes them into Claude Code’s own settings file for the project and turns on Claude Code’s sandbox, shows you the exact file before the first write, and takes only its own entries out when you stop managing the project. It is a guardrail, not a wall, and the page says so.
- Locked. The same rules go into macOS managed settings after one password prompt, so nothing in the project can loosen them.
- Maximum. Claude works in a sealed Docker box on a copy of the project. Your keys never go in: the box holds stand-ins, and a proxy between the box and the internet swaps in the real key on the way out, only for the site the key belongs to. Only the sites you allow are reachable, and changes come back for review before they touch your files.

Normal mode shows you the exact file before it writes anything.

The run above is a test: the model is a scripted stand-in and there is no internet. The attack and the blocking are real.

What the injected Claude tried to leave behind: a startup hook that downloads and runs a script. Both files are flagged before anything reaches your files.
Databases get one more level of detail: you can switch single columns, and Airlock creates a read-only login that reads only the columns you left on.

Every “Claude can’t” line is a claim Airlock has to earn. It works out Claude Code’s effective settings from every file that applies, checks that each line’s preconditions hold, and when it can’t be sure, it claims nothing.
#How I tested it
I built Airlock with Claude Code over five days, 28 October to 1 November 2026: one session planning and coordinating, others implementing, and separate reviewer sessions that only read the code and tried to break it. Nothing used my real keys: every test runs in a throwaway home folder full of fake secrets. The attack suite (airlock prove) runs the real claude binary in the box against a mock model and tries to get keys and data out. The UI checks drive the app in a headless browser.
How the evidence grew
Counts from the project log at the end of each phase, 28 October to 1 November 2026. Unit tests include the proxy’s Python tests.
| Phase | Unit tests | Attack suite | UI checks |
|---|---|---|---|
| Sealed box (28 Oct) | n/a | 19/19 | n/a |
| Control panel (28 Oct) | n/a | 23/23 | 11/11 |
| Access page (29 Oct) | 201 | 25/25 | 69/69 |
| Real projects (30 Oct) | 656 | 33/33 | 88/88 |
| One page per project (30 Oct) | 809 | 33/33 | 83/83 |
| Every project, one hub (31 Oct) | 930 | 33/33 | 120/120 |
| Locked, real DBs (1 Nov) | 1,429 | 38/38 | 135/135 |
On top of those, on the final version:
- Real databases. 58 tests against real PostgreSQL 16, MariaDB 11, MySQL 8.4, Oracle Free and Azure SQL Edge in throwaway containers, 0 failures.
- A native run. The real Claude Code 2.1.289 on this Mac, inside macOS’s own sandbox, with a mock model and a fake key. Across 9 setups (SSH on, internet rules, managed settings, odd ports and more), every “Claude can’t” line held.
- The binary as the judge. Airlock’s reading of the settings is compared with what Claude Code itself reports, in 320 generated layouts. 0 disagree.
- An edge-case list. 515 cases, each with what should happen and the exact test that proves it, or the reason it’s a limit. A script fails the build if a row names a test that doesn’t exist.
#What the reviews caught
The serious holes didn’t show up as failing unit tests. They came from reviewers asking “what if”, and from running against the real thing:
- The proxy trusted the wrong name. The key swap decided on the request’s
Hostheader but connected wherever the tunnel pointed. A tunnel to another host that claimed to beapi.anthropic.comgot the real key, with a 200. Fixed: Airlock now decides on the real destination, and it became an attack-suite check. - Opening a project could run the project’s code. A repository can name programs in its git config. Airlock’s own git calls ran them: a file-watcher setting in one round, a signature checker in the next. Git is now limited to 16 commands with every such setting pinned. A test repository sets all of them at once, and none ever runs.
- A read-only login that wasn’t. If a database login with Airlock’s name already existed with more rights,
REVOKEleft role memberships behind. After a setup that looked correct, the login still reademail. Only the real-database tests found it. - A “can’t” line that was false. Claude Code also opens its command sandbox to every site you allowed for web fetches. On the real binary,
curlreached a site with no prompt while Airlock’s page said Claude couldn’t. Fixed: Airlock now counts those sites the way Claude Code does, and a native run with web-fetch rules checks it. - The tests were a risk too. Run from a subfolder instead of the project root, the tests skipped their safety setup and could overwrite my real
~/.claude/settings.jsonand~/.gitconfig. It was found in review. Every test file now loads the setup itself, and any write outside the temp folder fails the run.
The main lesson: Claude Code’s documentation and schema weren’t enough to predict what it really does. The first time Airlock asked the real binary for its merged settings and compared them with its own reading, 29 of 60 layouts disagreed.
#What doesn’t work
- Normal is a guardrail. Blocking
git pushstops the usual ways of running it. A determined Claude can write a script that does the same. The page says so and points to Maximum for a hard block. - Connectors still connect. Airlock can deny a claude.ai connector’s tools, but Claude Code still connects to it. Only claude.ai can turn it off.
- 31 limits are written down, mostly crafted repositories, such as a special file in place of
.git/config. Each one says why it’s a limit. - Not built yet: a switch to block a project that redirects Claude Code’s own traffic (the page only names it), and blocking Claude from editing
CLAUDE.mdfiles. - Mac only. Maximum needs Docker Desktop.

Not everything locks from a project page: switches that apply to every project lock only from the Everywhere page, and while locked, Claude Code ignores the project’s own list of sites.
#My take
I stopped after 11 review rounds. Each round found a narrower kind of problem than the one before, and an exact model of a closed-source binary never quite converges. So I fixed the common bugs and the real holes, and wrote the rare cases down as limits.
I’d build it again, but I’d start where I ended: by asking the real Claude Code binary what it will do, before writing a single switch. Most of my bugs came from assuming what a settings file means rather than asking.
If you use Claude Code across several projects, and especially if any of them hold production keys or a database address, a page like this is worth having. If you only use Claude Code in one sandboxed repo with nothing secret in it, you don’t need it.
