MCP endpoint and skill setup (Claude and ChatGPT)
This is the step-by-step guide to driving Fissure from an AI agent:
how to start Fissure's MCP endpoint, and how to connect it to Claude
(Claude Code and Claude Desktop) or ChatGPT, with the
fissure_bug_bounty skill / methodology.
The picture: Fissure's engine is exposed over a token-gated loopback
HTTP control API (see docs/11_CONTROL_API.md). A thin MCP bridge
(bridge/fissure_mcp_bridge.py) turns each control-API route
into one MCP tool, so an MCP host drives the engine as an agent. The
fissure_bug_bounty skill wraps those tools in a full
engagement methodology. Nothing here weakens the ethics rules: the
engine enforces scope, the safe/aggressive toggle, and the authorization
banner regardless of the driver, and you still only test targets you are
authorized to assess.
AI agent (Claude / ChatGPT) --MCP--> fissure_mcp_bridge.py --HTTP+token--> Fissure control API --> engine
Step 1: start Fissure's MCP endpoint
The MCP endpoint is the control API plus the bridge. Start the control API first, then run the bridge.
1a. Enable the control API and get its token
Two ways, pick one:
Desktop app: Settings > Control API > tick "Enable local control API on 127.0.0.1 (automation / MCP bridge)". The section shows the running URL (
http://127.0.0.1:8777by default) and a token field; copy the token. The token is minted and persisted on first enable.Headless / CLI: run the server with a token you choose.
./fissure serve --host 127.0.0.1 --port 8777 --api-key <your-token>Verify it answers (status needs no token):
curl -s http://127.0.0.1:8777/api/status
The GUI's control API binds loopback (127.0.0.1) only.
fissure serve also binds loopback by default;
--host <addr> can bind another address, but only with
--api-key (or an explicit --insecure). Keep
the token secret: it grants full control of the engine.
1b. Locate the bridge and the skills
The bridge is two Python files (fissure_mcp_bridge.py
and its standard-library client fissure_control_client.py,
which must stay in the same directory). Every distribution ships them,
together with all of Fissure's Claude skills (one folder per skill,
currently fissure_bug_bounty), so a source checkout is not
required:
| Installed from | Bridge directory (<bridge-dir>) |
Skills directory (<skills-dir>) |
|---|---|---|
.deb package |
/opt/fissure/bridge |
/opt/fissure/skills |
| Windows installer | C:\Program Files\Fissure\bridge |
C:\Program Files\Fissure\skills |
| AppImage | extract it, see below | extract it, see below |
| Source checkout | <repo>/bridge |
<repo>/.claude/skills |
The Windows paths assume the default install directory.
An AppImage is a read-only image that is mounted at a different path on every run, so copy the two folders out of it once into a stable location:
mkdir -p ~/.local/share/fissure && cd ~/.local/share/fissure
/path/to/fissure-<version>-x86_64.AppImage --appimage-extract 'usr/bin/bridge/*'
/path/to/fissure-<version>-x86_64.AppImage --appimage-extract 'usr/bin/skills/*'
rm -rf bridge skills && mv squashfs-root/usr/bin/bridge squashfs-root/usr/bin/skills . && rm -rf squashfs-root
<bridge-dir> is then
~/.local/share/fissure/bridge and
<skills-dir> is
~/.local/share/fissure/skills. Repeat after upgrading the
AppImage so the bridge stays in step with the engine's routes.
1c. Install the bridge's Python dependency
Only the bridge needs the MCP Python SDK; its HTTP client
(bridge/fissure_control_client.py) is pure standard
library. Use a virtualenv so a bare python on the host is
not required to have mcp:
python3 -m venv ~/.venvs/fissure-mcp
~/.venvs/fissure-mcp/bin/pip install "mcp>=1.27,<2"
The bridge reads two environment variables for the upstream control
API: SUITE_API_URL (default
http://127.0.0.1:8777) and SUITE_API_TOKEN
(the token from step 1a). FISSURE_API_URL /
FISSURE_API_TOKEN are accepted as aliases.
A third, SUITE_API_TIMEOUT (alias
FISSURE_API_TIMEOUT, default 600 seconds), bounds how long
the bridge waits for one reply. Several routes are blocking by design:
plugin_run runs an external tool to completion and
reconchain runs every installed recon tool in sequence, so
a short timeout reports a transport error for a run that is still going
and will finish, which reads as a broken tool. An absent control API
refuses the connection immediately rather than hanging, so this value
only ever bounds real work. Raise it for a deliberately long tool run,
lower it if you want the agent to give up sooner.
Step 2: connect a client
Claude Code
Register the bridge as an MCP server (it launches as a local stdio subprocess):
claude mcp add fissure-control \
--env SUITE_API_URL=http://127.0.0.1:8777 \
--env SUITE_API_TOKEN=<token-from-step-1a> \
-- ~/.venvs/fissure-mcp/bin/python <bridge-dir>/fissure_mcp_bridge.py
With the .deb, for example, the last line is
-- ~/.venvs/fissure-mcp/bin/python /opt/fissure/bridge/fissure_mcp_bridge.py.
(Confirm the exact flags with claude mcp add --help.)
Install the skills by copying every folder of
<skills-dir> (step 1b) into your personal skills
directory, so they are available from any working directory:
mkdir -p ~/.claude/skills
cp -r /opt/fissure/skills/* ~/.claude/skills/
On Windows the personal skills directory is
%USERPROFILE%\.claude\skills. Copy them all rather than
picking one: each folder is a self-contained skill, and a later release
may ship more than fissure_bug_bounty. Re-run the copy
after an upgrade so the skills match the bridge's tools. From a source
checkout the skills under .claude/skills/ are also
auto-discovered when you run Claude Code inside the repository. Then ask
Claude to run a bug-bounty engagement and it will drive the tools with
the skill's methodology.
Claude Desktop
Claude Desktop launches MCP servers from its config file (Settings
> Developer > Edit config, or edit
claude_desktop_config.json directly). Add:
{
"mcpServers": {
"fissure-control": {
"command": "/home/you/.venvs/fissure-mcp/bin/python",
"args": ["<bridge-dir>/fissure_mcp_bridge.py"],
"env": {
"SUITE_API_URL": "http://127.0.0.1:8777",
"SUITE_API_TOKEN": "<token-from-step-1a>"
}
}
}
}Replace <bridge-dir> with the directory from step
1b (on Windows, the venv interpreter is Scripts\python.exe
inside the venv, and JSON paths need doubled backslashes). Restart
Claude Desktop; the Fissure tools appear in the tool list. To give it
the engagement methodology, install the skills: put every folder of
<skills-dir> in Claude Desktop's skills location (the
app's Skills feature, or its skills directory), or paste
fissure_bug_bounty/SKILL.md into the conversation / a
project's custom instructions as the playbook.
ChatGPT
ChatGPT has no "skills" mechanism; you supply the methodology as instructions and reach the engine one of two ways. Both require exposing a loopback service to ChatGPT's cloud, so read the security note below first.
Custom GPT Action (simplest). Fissure's control API is already plain HTTP with a bearer/
X-API-Keytoken, so a Custom GPT can call it directly via an Action: create a GPT, add an Action, paste an OpenAPI 3 schema describing the routes you want (from docs/11_CONTROL_API.md; e.g./api/status,/api/scan,/api/findings,/api/finding/highlight,/api/report), set API-key auth (headerX-API-Key), and pointservers.urlat the public URL of your tunnel (below). Paste the skill's methodology (.claude/skills/fissure_bug_bounty/SKILL.mdplusreferences/methodology.md) into the GPT's Instructions.MCP connector (developer mode). ChatGPT's MCP connectors expect a remote MCP server (streamable-HTTP / SSE), not a stdio subprocess, so run the bridge with a network transport:
SUITE_API_URL=http://127.0.0.1:8777 \ SUITE_API_TOKEN=<token-from-step-1a> \ FISSURE_MCP_TRANSPORT=streamable-http \ FISSURE_MCP_HOST=127.0.0.1 FISSURE_MCP_PORT=8779 \ ~/.venvs/fissure-mcp/bin/python <bridge-dir>/fissure_mcp_bridge.py(
FISSURE_MCP_TRANSPORT=sseis also accepted.) Add it as a connector in ChatGPT's developer mode, pointing at the public URL of the tunnel in front of port 8779 WITH the endpoint path: streamable-HTTP serves MCP at/mcp(for examplehttps://<tunnel-host>/mcp) and SSE at/sse; the bare host answers 404. 8779 is the bridge's default; it is one above the control-driven proxy's default 8778 (POST /api/proxy/startwithout aport), so both run with defaults.
Because ChatGPT runs in OpenAI's cloud, it cannot reach
127.0.0.1 on your machine directly: you must put a trusted
tunnel (for example an authenticated cloudflared or
ngrok tunnel) in front of the control API (for an Action)
or the bridge's HTTP transport (for a connector). A tunnel exposes an
authorized-testing control plane to the internet, so require the token
on every request, restrict the tunnel to ChatGPT's egress if you can,
and tear it down when finished. Claude Code / Claude Desktop run the
bridge locally over stdio and need no tunnel; prefer them when you
can.
Step 3: verify
Bridge deps and the API end to end (no MCP host needed):
cd <bridge-dir> SUITE_API_URL=http://127.0.0.1:8777 SUITE_API_TOKEN=<token> \ SUITE_TARGET_URL=http://127.0.0.1:4280/ \ python3 -c "import fissure_control_client as a; print(a.health())"From the AI host, ask it to call the
healthtool; it should return{"status":"ok","name":"fissure","version":"<x.y.z>"}(the control API's unauthenticatedGET /api/statusreply). Then ask it to runsurfaceor a scan against an authorized target.
See bridge/README.md for the full verification recipe
and the tool catalog, and
.claude/skills/fissure_bug_bounty/references/mcp_tools.md
for the authoritative per-tool reference (kept in exact parity with the
bridge's @mcp.tool definitions).
Security recap
- The control API is loopback + token-gated. Never commit the token; treat it like a password.
- Only test targets you are authorized to assess. Scope, the safe/aggressive toggle, and the authorization banner are enforced in the engine for every driver.
- Exposing the endpoint to a cloud AI (ChatGPT) requires a tunnel; that widens the attack surface of your own tooling. Keep it token-gated, short-lived, and prefer a local host (Claude Code / Claude Desktop) when possible.