whatsapp-mcp-setup
Skill4 starsChanged 4 months agoMITView on GitHub
Stand up WhatsApp on a new machine and wire the `whatsapp` MCP into both Claude clients — the WhatsApp add-on alongside mcp-bridge-setup. It builds the external whatsapp-mcp repo's TWO processes (the Go whatsmeow bridge, run as a launchd SIDECAR like search/guard on $WHATSAPP_GO_PORT/:8010; the Python stdio MCP, exposed to Claude Code via a supergateway bridge on $WHATSAPP_MCP_BRIDGE_PORT/:8006 and to Cowork as a direct stdio command), does the one-time QR pairing against your phone's Linked Devices, and registers `whatsapp` in `.mcp.json` + the Cowork config. Use when setting up WhatsApp on a new machine, when Cowork or Code can't see the `whatsapp` server, when the Go bridge is down, when /whatsapp-triage can't reach WhatsApp, or when the linked device was removed / the session expired and you must re-pair the QR.
- Reads credentials
- Installs packages
- Sends data out
In this repository17 other files it gives its agents.
- CLAUDE.mdCLAUDE.md
- mcp/CLAUDE.mdCLAUDE.md
- add-an-addonSkill
- backup-recoverySkill
- body-mcp-setupSkill
- cos-setupSkill
- cos-upgradeSkill
- debug-cowork-mcp-issuesSkill
- fitness-mcp-setupSkill
- guard-setupSkill
- hub-handoverSkill
- mcp-bridge-setupSkill
- nutrition-mcp-setupSkill
- openwhispr-mcp-setupSkill
- setup-vaultSkill
- spoke-setupSkill
- voice-operationsSkill
The file
We split this skill into the rules it gives an agent
1 rule. About 0 are common, 0 are distinctive, and 1 is very specific to this project.
≈0
Common · estimate
Many files like this have a rule of this kind.
≈0
Distinctive · estimate
This author's own choices. Worth a look.
1
Very specific
Tied to their project's names, files or tools. Probably skip.
- Common
- Distinctive
- Very specific
- Very specific: line 80
Run the loader preamble as the first line of every shell block below — it exports $REPO_ROOT, $WHATSAPP_MCP_DIR, $UV_BIN, $NODE_BIN, …
≈ “Common” is an estimate: at least 1 in 5 of the 372,429 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.
Files
WhatsApp MCP setup (Go bridge sidecar :8010 + Python stdio MCP bridge :8006)
Why this exists / architecture
whatsapp-mcp is an external repo (the user's fork
verygoodplugins/whatsapp-mcp) checked out
outside this Cos repo at $WHATSAPP_MCP_DIR. It is two processes, and they register
into Cos the same two ways the existing servers + sidecars do — getting this split wrong is the
usual failure:
- (a) The Go whatsmeow bridge (
:8010) —whatsapp-bridge/, a long-running HTTP daemon that holds the WhatsApp Web session and writes the SQLite stores. It is treated exactly like the search / guard SIDECARS: an HTTP backend, NOT a stdio MCP server, so it is NOT in.mcp.json. launchd supervises it under labelcom.chiefofstaff.mcp-whatsappbridge. (Its port is$WHATSAPP_GO_PORT, default 8010 — whatsmeow's own default is8080, but that is commonly taken on a dev box, so cos pins it to 8010.) - (b) The Python stdio MCP (
whatsapp-mcp-server/main.py) — a FastMCP stdio server (mcp.run(transport="stdio"), confirmed atmain.py:396). It is exposed to Claude Code over HTTP via a supergateway + launchd BRIDGE on:8006($WHATSAPP_MCP_BRIDGE_PORT, labelcom.chiefofstaff.mcp-whatsapp, IN.mcp.json), and to Claude Cowork Desktop as a direct stdiocommandentry — identical to how mcp-bridge-setup wires board/openwhispr/etc.
Claude Code ──HTTP──> localhost:8006/mcp ──supergateway(launchd)──> uv run main.py (Python stdio MCP)
│ reads SQLite directly (messages.db)
└──HTTP (bearer)──> Go bridge :8010 ──whatsmeow──> WhatsApp Web
Cowork Desktop ──spawns stdio directly──> uv run --directory $WHATSAPP_MCP_DIR/whatsapp-mcp-server main.py (§6)
Go bridge :8010 = launchd SIDECAR (com.chiefofstaff.mcp-whatsappbridge), NOT in .mcp.json (§4)The Python MCP reads messages.db directly for all the READ tools, so board-only triage
tolerates the Go bridge being down — but a fresh pairing or any send needs the bridge live
(see Gotchas). The data flow mirrors the upstream contract: AI client → Python MCP → reads SQLite
or calls the bridge REST ($WHATSAPP_API_URL) → Go bridge → WhatsApp Web.
This add-on's processes (alongside mcp-bridge-setup's four core servers + two sidecars, and the
optional openwhispr voice add-on):
| process | what runs | env | port | launchd label | in .mcp.json? |
| whatsappbridge (sidecar) | whatsapp-bridge/whatsapp-bridge (Go) | WHATSAPP_BRIDGE_PORT | 8010 | com.chiefofstaff.mcp-whatsappbridge | no (HTTP backend) |
| whatsapp (MCP bridge) | uv run --directory …/whatsapp-mcp-server main.py via supergateway | WHATSAPP_DB_PATH / WHATSMEOW_DB_PATH / WHATSAPP_API_URL | 8006 | com.chiefofstaff.mcp-whatsapp | yes (http://localhost:8006/mcp) |
The bearer token is read from a file, not the env. The Python server resolves the Go bridge's bearer token from
$WHATSAPP_MCP_DIR/whatsapp-bridge/store/.bridge-token(computed relative to its own__file__), so neither the plist nor the Cowork entry needs to carry it — the live secret never lands in~/Library/LaunchAgents, and a token rotation needs no re-render.
Board-only. Cos's
/whatsapp-triageuses ONLY the READ subset of this MCP (search_contacts,get_contact,list_messages,list_chats,get_chat,get_direct_chat_by_contact,get_contact_chats,get_last_interaction,get_message_context,download_media) — it reconciles WhatsApp onto the Cos board exactly like mail-to-board reconciles Gmail, and never callssend_message/send_file/send_audio_message. This setup skill stands up the plumbing; triage owns the board side.
Machine config comes from the loader (run the preamble in §1): it exports
$REPO_ROOT,$BREW_PREFIX,$NODE_BIN,$UV_BIN,$SUPERGATEWAY_BIN,$LAUNCH_AGENTS_DIR,$COWORK_CONFIG, and the new WhatsApp keys —$WHATSAPP_MCP_DIR(the external checkout),$WHATSAPP_MCP_BRIDGE_PORT(=8006),$WHATSAPP_GO_PORT(=8010), and the derived$WHATSAPP_MCP_BRIDGE_URL(=http://localhost:8006) /$WHATSAPP_GO_URL(=http://localhost:8010) — use those instead of hardcoding paths, the Homebrew prefix, your username, or ports.
Prerequisites
go(Homebrew:brew install go) — builds the whatsmeow bridge (go build). Required; the bridge is a compiled binary, there is no prebuilt one.uv(Homebrew:brew install uv) — runs the Python MCP server and provisions its venv (uv sync).supergateway(npm install -g supergateway) — the stdio→HTTP bridge for Claude Code (:8006), exactly as in mcp-bridge-setup.ffmpeg(optional;brew install ffmpeg) — only for the MCP'ssend_audio_messagevoice-note conversion. Triage never sends, so this is not needed for Cos; install only if you want outbound voice notes from other workflows.- A phone running WhatsApp for the one-time QR pairing (§3) — the analog of guard's gated-model HuggingFace login.
Run the loader preamble as the first line of every shell block below — it exports $REPO_ROOT,
$WHATSAPP_MCP_DIR, $UV_BIN, $NODE_BIN, $BREW_PREFIX, $LAUNCH_AGENTS_DIR, $COWORK_CONFIG,
the WhatsApp ports/URLs, etc., so nothing below is hardcoded. $U=$(id -u) is derived inline where
launchctl needs it.
source "$(git rev-parse --show-toplevel)/config/load-config.sh"Steps
1. Get the source (clone the fork, or point at an existing checkout)
The whatsapp-mcp repo lives outside this Cos checkout; $WHATSAPP_MCP_DIR (from cos.env) is
its path. Clone the user's fork there, or set WHATSAPP_MCP_DIR to a checkout you already have.
source "$(git rev-parse --show-toplevel)/config/load-config.sh"
if [ -d "$WHATSAPP_MCP_DIR/.git" ]; then
echo "whatsapp-mcp already at $WHATSAPP_MCP_DIR"
git -C "$WHATSAPP_MCP_DIR" remote -v | grep origin # origin should be verygoodplugins/whatsapp-mcp (the fork)
else
git clone https://github.com/verygoodplugins/whatsapp-mcp "$WHATSAPP_MCP_DIR"
fi
$WHATSAPP_MCP_DIRis acos.envkey (e.g.~/Code/whatsapp-mcp); set it there once. Theoriginremote is the forkverygoodplugins/whatsapp-mcp, not the upstreamlharries/whatsapp-mcp— PRs/issues against this checkout target the fork.
- CHECKPOINT — the two components are present:
source "$(git rev-parse --show-toplevel)/config/load-config.sh" ls "$WHATSAPP_MCP_DIR/whatsapp-bridge/main.go" "$WHATSAPP_MCP_DIR/whatsapp-mcp-server/main.py" \ && echo "source OK"
2. Build the bridge + install the server's deps
The Go bridge is compiled to a binary; the Python server's venv is provisioned by uv.
source "$(git rev-parse --show-toplevel)/config/load-config.sh"
( cd "$WHATSAPP_MCP_DIR/whatsapp-bridge" && go build -o whatsapp-bridge . ) # produces ./whatsapp-bridge
( cd "$WHATSAPP_MCP_DIR/whatsapp-mcp-server" && "$UV_BIN" sync ) # builds the venv from pyproject- CHECKPOINT — the binary exists and the server imports:
source "$(git rev-parse --show-toplevel)/config/load-config.sh" test -x "$WHATSAPP_MCP_DIR/whatsapp-bridge/whatsapp-bridge" && echo "bridge binary OK" "$UV_BIN" run --directory "$WHATSAPP_MCP_DIR/whatsapp-mcp-server" python -c "import main; print('server import OK')"
3. First-run QR pairing (HUMAN-IN-THE-LOOP — the one-time external auth)
Like guard's gated-model HuggingFace login, the bridge needs a one-time interactive
authorization: it prints a QR code you scan with your phone to link this machine as a
WhatsApp device. Run the bridge by hand once (foreground, NOT under launchd yet), on the
cos port so it doesn't collide with whatever holds :8080:
source "$(git rev-parse --show-toplevel)/config/load-config.sh"
cd "$WHATSAPP_MCP_DIR/whatsapp-bridge"
WHATSAPP_BRIDGE_PORT="$WHATSAPP_GO_PORT" ./whatsapp-bridge # prints a QR code in the terminal; leave it runningOn your phone: WhatsApp → Settings → Linked Devices → Link a Device, then scan the QR. On
success the bridge logs Connected to WhatsApp and begins history backfill, and it creates,
under whatsapp-bridge/store/ (all gitignored in the whatsapp-mcp repo — real chat history +
PII):
whatsapp.db— the whatsmeow session/contacts/LID map ($WHATSMEOW_DB_PATH),messages.db— the bridge's chats + messages, the read source of truth for the MCP ($WHATSAPP_DB_PATH),.bridge-token— the bearer token every REST call to the Go bridge must present (the Python server reads this file itself; you don't pass it anywhere).
Once you see Connected to WhatsApp and the stores exist, Ctrl-C — launchd will own the
process from §4.
History backfill is controlled by the phone (the primary device), not this machine — the bridge can request more (it supports a
--full-history-pairflag) but the phone has the final word. A freshly paired machine may show only recent history at first; triage's per-chat cursor simply starts from whatmessages.dbhas.
- CHECKPOINT — the three store files exist:
source "$(git rev-parse --show-toplevel)/config/load-config.sh" ls "$WHATSAPP_MCP_DIR/whatsapp-bridge/store/whatsapp.db" \ "$WHATSAPP_MCP_DIR/whatsapp-bridge/store/messages.db" \ "$WHATSAPP_MCP_DIR/whatsapp-bridge/store/.bridge-token" && echo "store OK"
4. Install both LaunchAgents (Go bridge SIDECAR :8010 + Python MCP bridge :8006)
The Go bridge is an HTTP daemon (like search/guard sidecars), so it gets a LaunchAgent but no
.mcp.json entry; the Python MCP is bridged to HTTP for Claude Code via a supergateway LaunchAgent
on :8006. Both plists are generated from their descriptors
(mcp/whatsapp/whatsapp.service.json + whatsappbridge.service.json) by scripts/gen-launchd.mjs
(see mcp/CLAUDE.md) — which on macOS renders the plist AND bootout→bootstrap→kickstarts it in one
step. Name both add-on services explicitly (they aren't core):
source "$(git rev-parse --show-toplevel)/config/load-config.sh"
node "$REPO_ROOT/scripts/gen-launchd.mjs" --install whatsapp whatsappbridgeThe whatsappbridge descriptor runs the built whatsapp-bridge binary with
WHATSAPP_BRIDGE_PORT=$WHATSAPP_GO_PORT, WorkingDirectory = $WHATSAPP_MCP_DIR/whatsapp-bridge
(so it finds store/), RunAtLoad + KeepAlive, a PATH that starts with $BREW_PREFIX/bin, and
logs to $REPO_ROOT/mcp/logs/whatsappbridge.{out,err}.log.
Probe leniently — it is bearer-token protected. The REST API requires the
.bridge-tokenbearer, so an unauthenticatedcurlreturns 401, not 200 — a bare 200 is NOT the health signal. The signal is: the port is listening AND the log saysConnected to WhatsApp(the session is live). Don't treat the 401 as a failure.
- CHECKPOINT — port up + session connected:
source "$(git rev-parse --show-toplevel)/config/load-config.sh" lsof -nP -iTCP:"$WHATSAPP_GO_PORT" -sTCP:LISTEN >/dev/null 2>&1 && echo "bridge listening on :$WHATSAPP_GO_PORT" grep -q "Connected to WhatsApp" "$REPO_ROOT/mcp/logs/whatsappbridge.out.log" 2>/dev/null && echo "session connected" # An authenticated probe (optional) — should NOT be 401 with the token: curl -s -o /dev/null -w '%{http_code}\n' -H "Authorization: Bearer $(cat "$WHATSAPP_MCP_DIR/whatsapp-bridge/store/.bridge-token")" \ "$WHATSAPP_GO_URL/api/chats" ; echo
5. The Python MCP supergateway BRIDGE (:8006)
The stdio MCP is bridged to HTTP for Claude Code exactly like mcp-bridge-setup's servers — one
supergateway LaunchAgent on :8006, generated from mcp/whatsapp/whatsapp.service.json and
already installed by the gen-launchd.mjs --install whatsapp whatsappbridge run in §4. The
generated plist's EnvironmentVariables carry the three vars the Python server reads to find its
stores + the Go bridge (all absolute / explicit):
WHATSAPP_DB_PATH=$WHATSAPP_MCP_DIR/whatsapp-bridge/store/messages.db,WHATSMEOW_DB_PATH=$WHATSAPP_MCP_DIR/whatsapp-bridge/store/whatsapp.db,WHATSAPP_API_URL=http://localhost:$WHATSAPP_GO_PORT/api(pinned to the Go bridge — see the Gotcha).
The bearer token is not in the plist — the server reads store/.bridge-token itself.
Do NOT set
WHATSAPP_BRIDGE_PORTin this plist. It is read by the Go bridge only (the port it binds); the Python MCP ignores it and reaches the Go bridge solely viaWHATSAPP_API_URL. Setting it here would be a silent no-op. The supergateway bridge port (8006) is namedWHATSAPP_MCP_BRIDGE_PORTincos.envand passed to supergateway's--port. (See Gotchas.)
- CHECKPOINT — an MCP
initializeon:8006returnsserverInfo.name == "whatsapp":source "$(git rev-parse --show-toplevel)/config/load-config.sh" curl -s -X POST "$WHATSAPP_MCP_BRIDGE_URL/mcp" \ -H 'Content-Type: application/json' -H 'Accept: application/json, text/event-stream' \ -d '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2024-11-05","capabilities":{},"clientInfo":{"name":"c","version":"0"}}}' \ | grep -o '"name":"whatsapp"' && echo "whatsapp MCP bridge OK"
6. Register BOTH clients (each registers differently!)
As in mcp-bridge-setup, the two clients register differently — getting this wrong is the usual
failure. Both entries are generated from mcp/whatsapp/whatsapp.service.json (see mcp/CLAUDE.md).
Claude Code — HTTP via the bridge. .mcp.json is generated + CI-checked, so regenerate it
(it picks up whatsapp → http://localhost:8006/mcp from the descriptor, alongside the existing
board/openwhispr/calendar/guard/vault entries):
source "$(git rev-parse --show-toplevel)/config/load-config.sh"
node "$REPO_ROOT/scripts/gen-mcp-json.mjs"Claude Cowork Desktop — direct stdio. claude_desktop_config.json ($COWORK_CONFIG) accepts
stdio command servers only (an HTTP url is rejected — same validated rule as
mcp-bridge-setup §5). Cowork spawns the Python MCP itself via uv. Merge just the whatsapp entry
(named = additive, backup-first to .bak, secrets inlined from the resolved descriptor):
source "$(git rev-parse --show-toplevel)/config/load-config.sh"
node "$REPO_ROOT/scripts/gen-cowork-config.mjs" whatsappThe
WHATSAPP_API_URLpinned to the Go bridge (http://localhost:$WHATSAPP_GO_PORT/api), never the:8006MCP-bridge port; the token is read fromstore/.bridge-tokenby the server.
- Absolute
uvpath ($UV_BIN, from the loader): Claude Desktop's spawn env, like launchd's, lacks Homebrew onPATH. - Quit + reopen Claude Desktop (⌘Q) — it reads this file only at launch; then
whatsappappears in Cowork's tools. - CHECKPOINT — both registrations present:
source "$(git rev-parse --show-toplevel)/config/load-config.sh" grep -q '"whatsapp"' "$REPO_ROOT/.mcp.json" && echo ".mcp.json OK" "$NODE_BIN" -e 'const c=require(process.env.COWORK_CONFIG);process.exit(c.mcpServers&&c.mcpServers.whatsapp?0:1)' \ && echo "Cowork config OK"
7. Confirm the nudge loop picks up both processes
ensure-bridges.sh so npm run dev/start brings WhatsApp up with the rest — but you do not edit
it by hand. It is a thin consumer of node mcp/service-manifest.mjs --probe-list, so the two
descriptors (whatsapp.service.json + whatsappbridge.service.json) feed it automatically: the MCP
bridge probes by httpListen on :8006, the Go sidecar by bearerHealth on :8010 (a
cold/unpaired bridge that isn't listening yet just prints a WARN … DOWN — board-only triage still
reads SQLite, so that's a nudge, not a hard failure).
- CHECKPOINT — the script bootstraps both and reports them up:
source "$(git rev-parse --show-toplevel)/config/load-config.sh" "$REPO_ROOT/mcp/ensure-bridges.sh" | grep -Ei 'whatsapp' # expect: "[mcp] whatsapp bridge up on :8006" and "[mcp] whatsappbridge bridge up on :8010"
8. End-to-end verify
Confirm the whole add-on works from the MCP surface, not just the ports:
source "$(git rev-parse --show-toplevel)/config/load-config.sh"
# (a) list_chats through the whatsapp MCP returns real chats (reads messages.db):
curl -s -X POST "$WHATSAPP_MCP_BRIDGE_URL/mcp" \
-H 'Content-Type: application/json' -H 'Accept: application/json, text/event-stream' \
-d '{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name":"list_chats","arguments":{"limit":3}}}' \
| grep -o '"jid"' | head -1 && echo "list_chats returned data"
# (b) the Go bridge session is live:
grep -q "Connected to WhatsApp" "$REPO_ROOT/mcp/logs/whatsappbridge.out.log" && echo "bridge connected"- CHECKPOINT —
list_chatsreturns chat data, the bridge log showsConnected to WhatsApp, and both clients seewhatsappafter a ⌘Q reopen. The cursor/board flow (per-chat watermark at$REPO_ROOT/config/whatsapp-triage-state.json, guard-scanned untrusted input, board reconciliation) is then exercised by/whatsapp-triage— that skill owns the board side; this one only proves the plumbing.
Manage
launchctl kickstart -k gui/$(id -u)/com.chiefofstaff.mcp-whatsapp # restart the MCP bridge
launchctl kickstart -k gui/$(id -u)/com.chiefofstaff.mcp-whatsappbridge # restart the Go sidecar
launchctl bootout gui/$(id -u)/com.chiefofstaff.mcp-whatsapp # stop the MCP bridge
tail -f mcp/logs/whatsappbridge.out.log # Go bridge log ("Connected to WhatsApp")
tail -f mcp/logs/whatsapp.err.log # supergateway / Python MCP logRe-pair after a session loss: stop both agents, repeat §3 (foreground
WHATSAPP_BRIDGE_PORT=$WHATSAPP_GO_PORT ./whatsapp-bridge, scan the new QR), then kickstart -k
both agents. The token may rotate, but the server reads it from store/.bridge-token at runtime, so
no plist/Cowork re-render is needed — just restart the agents to pick up a fresh session.
Gotchas (read before editing)
WHATSAPP_BRIDGE_PORTis the GO bridge's var — the Python MCP never reads it. Only the Go whatsmeow bridge (whatsapp-bridge/main.go) readsWHATSAPP_BRIDGE_PORT, as the port it binds. The Python MCP server reads onlyWHATSAPP_DB_PATH,WHATSMEOW_DB_PATH,WHATSAPP_API_URL, andWHATSAPP_BRIDGE_TOKEN(whatsapp.py) — it locates the Go bridge solely viaWHATSAPP_API_URL. So: the Go sidecar plist setsWHATSAPP_BRIDGE_PORT=$WHATSAPP_GO_PORT; the Python MCP plist must not set it (a silent no-op). On the cos side the two ports get distinct names —WHATSAPP_MCP_BRIDGE_PORT(the supergateway bridge, 8006) andWHATSAPP_GO_PORT(the Go sidecar, 8010) — keeping the literalWHATSAPP_BRIDGE_PORTconfined to the one plist that owns it. PinWHATSAPP_API_URL=http://localhost:$WHATSAPP_GO_PORT/apiso the server reaches the Go bridge explicitly, no matter what.- Why :8010, not :8080. whatsmeow's default bridge port is
8080, which is commonly already taken on a dev machine. cos pins the Go bridge to$WHATSAPP_GO_PORT(default 8010) in the sidecar plist and the §3 pairing run, and pointsWHATSAPP_API_URLat it. If8010is also taken, changeWHATSAPP_GO_PORTincos.envand re-run the §4gen-launchd.mjs --install whatsapp whatsappbridge(both plists regenerate from their descriptors with the new port). - Reads work straight from SQLite even if the Go bridge is down. The Python MCP reads
messages.dbdirectly for all READ tools, so board-only/whatsapp-triagetolerates a down Go bridge (it never needs the bridge for reads). But a fresh pairing or ANY send needs the bridge live — so keep the sidecar's probe in §7 lenient and don't make triage depend on it. - Re-pair when the linked device is removed or the session expires. If you remove this machine
from the phone's Linked Devices, or WhatsApp expires the session, the bridge logs a
disconnect and reads go stale. Redo §3 (foreground
./whatsapp-bridgeon$WHATSAPP_GO_PORT, scan the new QR), then restart both agents. - A Go toolchain is required to build. There is no prebuilt bridge binary —
go buildis mandatory in §2. Missinggo→ no daemon → no pairing and no sends (reads still work off an existingmessages.db, but a fresh machine has none until §3 runs). store/holds real chat history + PII and is gitignored in the whatsapp-mcp repo.whatsapp.db,messages.db, the per-chat media understore/{chat_jid}/, and.bridge-tokenare all sensitive and machine-local — never commit them. The token never enters a committed file or the installed plist (the server reads it fromstore/). Cos's encrypted backup covers the Cos repo's own stores, not this externalstore/.- Ports
8006and8010must be free (lsof -nP -iTCP:8006 -sTCP:LISTEN,lsof -nP -iTCP:8010 -sTCP:LISTEN).8006sits just past mcp-bridge-setup's8001–8005bridges;8010sits just past the8008/8009sidecars. A foreign process on either breaks the corresponding step — pick another free port incos.envif so. - launchd cannot expand
$VARS. As with every Cos plist, the rendered plists in~/Library/LaunchAgentscarry literal absolute paths (resolved from the loader bygen-launchd.mjsin §4) and aPATHthat starts with$BREW_PREFIX/bin— launchd never inherits your login shell and can't see an nvm/asdf shim, so theuv/go-built binary paths must be literal, not acommand -vshim.
Does it work?
Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.
No reviews yet
People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.
- It worked
- Partly
- It didn't
Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.
Your trail
Files you open will collect here, so you can find them again.
Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.
Now do this for your own.
Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.

