Fissuredocumentation v5.3.1
On this page

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:8777 by 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-Key token, 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 (header X-API-Key), and point servers.url at the public URL of your tunnel (below). Paste the skill's methodology (.claude/skills/fissure_bug_bounty/SKILL.md plus references/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=sse is 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 example https://<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/start without a port), 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 health tool; it should return {"status":"ok","name":"fissure","version":"<x.y.z>"} (the control API's unauthenticated GET /api/status reply). Then ask it to run surface or 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.