cabal-hunter-mcp 0.1.0 → 1.0.2

package/.dockerignore

@@ -0,0 +1,4 @@
+node_modules
+.git
+demo
+example_bot.py

package/.mcp.json

@@ -0,0 +1,8 @@
+{
+  "mcpServers": {
+    "cabal-hunter": {
+      "url": "https://api.cabal-hunter.com/mcp",
+      "description": "On-chain Solana token cabal detection — traces coordinated wallet funding before you buy"
+    }
+  }
+}

package/Dockerfile

@@ -0,0 +1,17 @@
+# Cabal-Hunter local stdio MCP server.
+# Used by Glama (and any MCP host) to build + run the server for automated
+# tool discovery and quality checks. Requires no secrets — the free tier works
+# out of the box; paid scans use x402 at call time.
+FROM node:20-slim
+
+WORKDIR /app
+
+# Install deps first for layer caching.
+COPY package.json ./
+RUN npm install --omit=dev --no-audit --no-fund
+
+# Copy the server.
+COPY server ./server
+
+# MCP servers speak JSON-RPC over stdio.
+ENTRYPOINT ["node", "server/index.mjs"]

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2026 Cabal-Hunter
+Copyright (c) 2026 Cabal-Hunter (paulf280-ui)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -1,95 +1,444 @@
-# cabal-hunter-mcp
+# Solana Safe Sniper — MCP Template
 
-**On-chain Solana cabal & rug detection as an MCP server.** One tool — `check_cabal_risk` — scans any Solana token mint *before your agent buys* and returns an **Exit-Liquidity Risk** verdict (`SAFE | REVIEW | AVOID`), a 0–100 cabal score, funding-cluster detection, same-block Jito-bundle detection, coordinated-dump detection, serial-rug **deployer history** ("launched 14, 13 dead"), and a Solana-native **honeypot** check (freeze authority + Token-2022 traps). Every flag links to its on-chain evidence transaction.
-
-[![npm](https://img.shields.io/npm/v/cabal-hunter-mcp?color=cb3837&logo=npm)](https://www.npmjs.com/package/cabal-hunter-mcp)
 [![MCP server](https://img.shields.io/badge/MCP-server-7c3aed)](https://api.cabal-hunter.com/mcp)
 [![Solana](https://img.shields.io/badge/Solana-on--chain-14F195)](https://api.cabal-hunter.com)
-[![Free tier](https://img.shields.io/badge/250%2Fmo%20free-no%20API%20key-10b981)](https://api.cabal-hunter.com/api/info)
+[![Live demo](https://img.shields.io/badge/%E2%96%B6%20live-holder%20map-2dd4bf)](https://api.cabal-hunter.com/demo)
+[![Free tier](https://img.shields.io/badge/250%2Fmo%20free-then%20%240.001-ff4d6d)](https://api.cabal-hunter.com/api/info)
+[![Install MCP in VS Code](https://img.shields.io/badge/VS_Code-One--click_MCP_install-0098FF?logo=githubcopilot&logoColor=white)](https://insiders.vscode.dev/redirect/mcp/install?name=cabal-hunter&config=%7B%22type%22%3A%20%22http%22%2C%20%22url%22%3A%20%22https%3A%2F%2Fapi.cabal-hunter.com%2Fmcp%22%7D)
+[![Install MCP in Cursor](https://img.shields.io/badge/Cursor-One--click_MCP_install-111111)](https://cursor.com/install-mcp?name=cabal-hunter&config=eyJ1cmwiOiAiaHR0cHM6Ly9hcGkuY2FiYWwtaHVudGVyLmNvbS9tY3AifQ==)
+[![ElizaOS plugin](https://img.shields.io/badge/ElizaOS-plugin--cabal--hunter-7c3aed)](https://github.com/paulf280-ui/plugin-cabal-hunter)
 [![License: MIT](https://img.shields.io/badge/license-MIT-94a3b8)](LICENSE)
 
-Contract-clean is **not** cabal-clean. RugCheck-style scanners tell you the mint/freeze/LP are fine — they don't tell you that 15 wallets funded from one source are holding 30% of supply, waiting to dump on you. That's what this catches.
+> 🌐 **Available in 9 languages:** [English](https://api.cabal-hunter.com/) · [Español](https://api.cabal-hunter.com/es) · [Português](https://api.cabal-hunter.com/pt) · [Français](https://api.cabal-hunter.com/fr) · [Deutsch](https://api.cabal-hunter.com/de) · [Nederlands](https://api.cabal-hunter.com/nl) · [中文](https://api.cabal-hunter.com/zh) · [日本語](https://api.cabal-hunter.com/ja) · [한국어](https://api.cabal-hunter.com/ko)
 
-## Quick start
+![Cabal-Hunter — live Solana cabal and rug analysis: interactive 3D holder map, serial-launcher deployer history, and an Exit-Liquidity Risk verdict](demo/screenshot.png)
 
-```bash
-npx cabal-hunter-mcp
+> Stop your AI trading agents getting rugged by coordinated wallet cabals.
+> Drop-in template for Claude Code, Cursor, and ElizaOS.
+
+**▶ Try it now: [live 3D holder map of any Solana token →](https://api.cabal-hunter.com/demo)** — no signup.
+
+**Cabal-Hunter is a free on-chain Solana token safety scanner and rug checker.** It detects coordinated wallet cabals, same-block Jito bundle buys, serial-launcher deployers and coordinated dumps on any Solana mint (pump.fun, PumpSwap, Raydium) — and answers the one question that matters before you ape: *are you the exit liquidity?* Use it via **MCP** (Claude, Cursor, ElizaOS), a **REST API**, or a free **interactive 3D holder map**.
+
+---
+
+## The Problem
+
+Your autonomous trading agent is reading rug.check scores, liquidity locks, and contract audits.
+
+**None of that catches a cabal.**
+
+A handful of wallets take the bottom of a launch, the chart looks clean — contract fine, LP burned, everything green — and then they sell into whoever bought after them. You are the exit liquidity.
+
+This template integrates **[Cabal-Hunter](https://api.cabal-hunter.com)** as a pre-trade safety check, so your agent can see who is holding and who has already positioned to sell before it signs a swap.
+
+> **A note on what we do and don't claim.** This README used to open with "15 fresh wallets funded from the same master wallet, accumulating 25-40% of supply." We went looking for that pattern and could not find it. Tracing 323 pump.fun launches at the bonding curve turned up **zero coordinated funding clusters**, and showed why: the median launch has about **five successful buyers**, because on one representative token **1,260 of the curve's 1,266 transactions failed**. Launch capture is a sniper *race* between competing bots, not a quiet cabal. The detection layers below are the ones we can actually evidence — holder concentration, same-block bundles, coordinated selling and deployer history. The pre-launch funding tracer was withdrawn; the [full write-up is here](https://github.com/paulf280-ui/cabal-hunter-mcp#a-note-on-the-withdrawn-trace_funding-tool).
+
+---
+
+## The one question it answers: are YOU the exit liquidity?
+
+The classic pump.fun exit-liquidity setup: wallets positioned before the crowd take the bottom of a launch, then dump on the retail (and bots) that pile in after. Cabal-Hunter's headline output is a single **Exit-Liquidity Risk** verdict (`LOW | ELEVATED | HIGH`) that synthesises every signal below into the only thing that matters before you sign a swap: *are the insiders positioned to dump on you?*
+
+## What Cabal-Hunter Does
+
+```
+Token mint address
+      ↓
+0. EXIT-LIQUIDITY RISK — the headline verdict. Synthesises the layers
+   below (bundle, concentration, shared funder, coordinated dump, serial-
+   rug dev) into LOW | ELEVATED | HIGH: are insiders set up to dump on
+   a buyer? The one number a trading agent needs.
+      ↓
+1. HOLDER FUNDING LINEAGE — the CURRENT top holders walked back: were
+   they seeded by the same wallet? Only System-owned accounts count as
+   a funder, so pools, vaults and routers can never be mistaken for a
+   person (that mistake is exactly what got our pre-launch tracer
+   withdrawn). Every cluster carries evidence_txs[] — the actual
+   funding transactions on Solscan. This layer is genuinely rare to
+   fire; treat a hit as significant and its absence as no evidence
+   either way.
+      ↓
+2. SAME-BLOCK BUNDLE DETECTION — holders whose token accounts were
+   created in the EXACT same slot bought in one Jito bundle. Catches
+   stealth launches that route funding through intermediaries to
+   evade layer 1. Returned as `time_sync: true`.
+      ↓
+3. COORDINATED DUMP DETECTION — ≥2 holders that SOLD a meaningful chunk
+   (≥25% of their bag each) in the EXACT same block — a cabal exiting in
+   real time. `coordinated_exit: true`, with sold_pct = % of supply
+   dumped and the sell transactions linked. Same-slot + meaningful-size +
+   distinct wallets = near-zero false positives.
+      ↓
+4. DEV TRACK RECORD — the creator wallet is resolved on-chain (bonding
+   curve pre-graduation, pump-amm pool after — works on any age token),
+   and their full launch history is pulled WITH THE PEAK MARKET CAP each
+   past token hit. A dead-count alone hides a pump-and-dump: a dev whose
+   tokens all died at $4k is a nobody, but one who ran a token to $728k
+   then dumped it to dust has done it to holders before. Reputation:
+   SERIAL_RUGGER | DEAD_ON_ARRIVAL | MIXED | PROVEN, with per-launch
+   peak → now (paid tier returns the full launches[] array).
+      ↓
+5. CEX-NOISE FILTER — holders funded from a shared exchange or
+   high-volume infra wallet are NOT a cabal. They're excluded from the
+   score and surfaced transparently in filtered_clusters[], so you never
+   get a false positive from people who just withdrew from Binance.
+      ↓
+6. HONEYPOT CHECK (Solana-native) — one RPC read of the mint account:
+   is the FREEZE authority live (issuer can freeze your tokens — the
+   sell-block lever)? is the MINT authority live (supply can be
+   inflated)? any Token-2022 traps (transfer fees up to 100%, transfer
+   hooks that block sells, permanent-delegate clawback)? On Solana a
+   "honeypot" is built from these — tokens have no per-token contract
+   code to audit. Returns `honeypot_risk: LOW | HIGH` +
+   `freeze_authority_revoked` / `mint_authority_revoked` /
+   `token2022_risks[]`.
+      ↓
+Returns: Cabal Score (0-100) + cluster map + deployer verdict
+         + honeypot verdict + on-chain receipts + hard verdict
 ```
 
-No install, no signup, no API key — **250 free scans/month per IP**. That's the whole setup; the command below is what you drop into any MCP client.
+The deployer layer is the one cabals can't dodge: **wallets rotate, deployers leave a paper trail.** A response of `"deployer": {"reputation": "SERIAL_RUGGER", "tokens_launched": 22, "best_peak_usd": 728432, "pump_and_dumps": 2}` shows the dev's full track record before the first candle — including whether this "dead" dev has quietly run tokens to six figures and dumped them on holders before. (Honest context: most prolific pump.fun creators have high dead-token rates, so this signal is capped — it flags a token for review but never drives a HIGH verdict on its own.)
 
-### Claude Desktop / Claude Code / Cursor / VS Code / ElizaOS
+**Receipts, not magic.** Every cluster and red flag links to the underlying Solscan transaction (`evidence_txs[]`, `holders[].funding_tx`) — verify the trail yourself instead of trusting a score.
+
+**Response in <100ms** on pre-indexed tokens — every pump.fun graduation is scanned and cached automatically as it happens.
+
+**Free tier: 250 scans/month per IP.** Then $0.001 USDC per scan — priced at cost (it covers the Helius RPC calls behind each live on-chain trace), paid natively on Solana. No account. No API key. No subscription.
+
+---
+
+## Quick Start
+
+### 1. Claude Code / Claude Desktop
+
+Add to your MCP config (`~/.claude/mcp.json` or project `.mcp.json`):
 
 ```json
 {
   "mcpServers": {
     "cabal-hunter": {
-      "command": "npx",
-      "args": ["-y", "cabal-hunter-mcp"]
+      "url": "https://api.cabal-hunter.com/mcp"
     }
   }
 }
 ```
 
-Prefer a remote HTTP server (no local process)? Point straight at the hosted endpoint instead:
+That's it. Claude will now call `check_cabal_risk` automatically when you ask it to analyse a Solana token.
+
+**Example prompt:**
+> "Before we buy into this token, check if there are any coordinated wallets: `EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v`"
+
+Claude calls the tool, pays $0.001 USDC from your connected wallet, and returns the full analysis.
+
+---
+
+### 2. Cursor
+
+Add to `.cursor/mcp.json` in your project root:
 
 ```json
-{ "mcpServers": { "cabal-hunter": { "url": "https://api.cabal-hunter.com/mcp" } } }
+{
+  "mcpServers": {
+    "cabal-hunter": {
+      "url": "https://api.cabal-hunter.com/mcp"
+    }
+  }
+}
+```
+
+---
+
+### 3. ElizaOS (with automatic x402 payment)
+
+If you're using ElizaOS with `@hugen/plugin-x402-solana`, payment is handled automatically. Add to your agent config:
+
+```json
+{
+  "plugins": ["@hugen/plugin-x402-solana"],
+  "mcpServers": {
+    "cabal-hunter": {
+      "url": "https://api.cabal-hunter.com/mcp"
+    }
+  }
+}
+```
+
+Your agent will call `check_cabal_risk(mintAddress)` before any swap and abort if `cabalScore >= 35` or `isControlled === true`.
+
+---
+
+### 4. Direct REST API
+
+For headless scripts, custom bots, or any language. **The first 250 calls/month are free — no key, no signup.** Just call it:
+
+```bash
+curl "https://api.cabal-hunter.com/api/scan-cabal?mintAddress=YOUR_MINT_ADDRESS"
+```
+
+You get the full analysis back immediately, with `free_queries_remaining` so you always know where you stand. Machine-readable contract: [`/openapi.json`](https://api.cabal-hunter.com/openapi.json).
+
+Once the free tier is used up, calls are $0.001 USDC via x402 — your agent just pays, no billing setup:
+
+**Step 1 — Request analysis (get payment instructions):**
+```bash
+curl -X POST https://api.cabal-hunter.com/api/scan-cabal \
+  -H "Content-Type: application/json" \
+  -d '{"mintAddress": "YOUR_MINT_ADDRESS"}'
 ```
 
-## The tool
+Response (HTTP 402):
+```json
+{
+  "error": "payment_required",
+  "payment": {
+    "recipient": "ATYjZ1kWoHWhj74umGJ8wFqUeW1yeSGBbLi1UQpahPxt",
+    "amount_usdc": 0.001,
+    "memo_required": "ch-xxxx-xxxx-xxxx",
+    "instructions": "Send 0.001 USDC with this memo, then resubmit with X-Payment-Signature header"
+  }
+}
+```
 
-**`check_cabal_risk({ mint })`** — pass a Solana token mint (contract) address. Returns the full forensic JSON:
+**Step 2 — Pay & resubmit:**
+```bash
+curl -X POST https://api.cabal-hunter.com/api/scan-cabal \
+  -H "Content-Type: application/json" \
+  -H "X-Payment-Signature: YOUR_TX_SIGNATURE" \
+  -d '{"mintAddress": "YOUR_MINT_ADDRESS"}'
+```
 
-```jsonc
+**Response (HTTP 200):**
+```json
 {
-  "recommendation": "AVOID",        // SAFE | REVIEW | AVOID  ← the headline
-  "risk": "HIGH",                   // exit-liquidity risk
-  "cabal_score": 100,               // 0-100
-  "honeypot_risk": "LOW",           // freeze authority + Token-2022 traps
-  "mint_authority_revoked": true,
-  "freeze_authority_revoked": true,
-  "deployer": { "verdict": "SERIAL_RUGGER", "tokens_launched": 14, "dead": 13 },
+  "mint": "YOUR_MINT",
+  "token_name": "EXAMPLE",
+  "risk": "HIGH",
+  "cabal_score": 72.4,
+  "is_controlled": true,
+  "time_sync": true,
+  "verdict": "AVOID — 4 wallets bought in the EXACT same block (bundled launch), controlling 34.1% of supply. DEPLOYER ALERT: this creator has launched 14 tokens, 13 of 13 checked are dead (100%).",
   "coordinated_clusters": [
-    { "wallets": 5, "combined_pct": 23.1, "evidence_tx": "https://solscan.io/tx/…" }
+    {
+      "type": "funding",
+      "master_full": "FvbEKF...9RUg",
+      "master_short": "FvbEKF…9RUg",
+      "wallet_count": 4,
+      "combined_pct": 34.1,
+      "risk": "HIGH",
+      "evidence_txs": ["4Y8auc5G...", "2XQx9LFv...", "AAbJ7rej..."]
+    }
   ],
-  "time_sync": true,                // same-block (Jito-bundled) buys
-  "coordinated_exit": false,        // ≥2 holders dumped together
-  "top_reasons": ["..."],
-  "wallets_checked": 15,
-  "scan_complete": true
+  "filtered_clusters": [
+    {
+      "funder_label": "high-volume wallet",
+      "master_short": "43ViqZ…Z6iy",
+      "wallet_count": 2,
+      "combined_pct": 4.4
+    }
+  ],
+  "deployer": {
+    "creator": "5TbRN6...full address...",
+    "creator_short": "5TbRN6…2TGC",
+    "tokens_launched": 14,
+    "dead": 13,
+    "sampled": 13,
+    "dead_pct": 100.0,
+    "verdict": "SERIAL_LAUNCHER"
+  },
+  "holders": [
+    { "rank": 1, "address": "...", "pct": 12.4, "cluster_id": 0, "funding_tx": "4Y8auc5G..." }
+  ],
+  "wallets_checked": 12,
+  "analysis_time_ms": 487,
+  "source": "real_time"
+}
+```
+
+### 5. Run the MCP server locally (Docker / Node)
+
+**Fastest — no clone needed:** `npx cabal-hunter-mcp` — the same stdio server, published to npm ([cabal-hunter-mcp](https://github.com/paulf280-ui/cabal-hunter-mcp) · [npm](https://www.npmjs.com/package/cabal-hunter-mcp)). Or run it from this repo:
+
+Prefer to run the connector yourself instead of hitting the hosted `/mcp`
+endpoint? This repo ships a thin **stdio MCP server** that exposes
+`check_cabal_risk(mintAddress)` and proxies to the Cabal-Hunter API (free tier
+works with no key; paid scans use x402 at call time):
+
+```bash
+# Node 18+
+npm install
+node server/index.mjs
+
+# or Docker
+docker build -t cabal-hunter-mcp .
+docker run -i cabal-hunter-mcp
+```
+
+Then point any MCP client at the local command:
+
+```json
+{
+  "mcpServers": {
+    "cabal-hunter": {
+      "command": "node",
+      "args": ["server/index.mjs"]
+    }
+  }
 }
 ```
 
-`scan_complete` / `wallets_checked` are included on purpose so your agent can apply **its own** risk tolerance instead of inheriting ours — the score is a starting point you can verify (every cluster carries an `evidence_tx`), not a verdict you take on faith.
+---
+
+## Integrate into Your Trading Logic
+
+```python
+import requests
+
+def is_safe_to_buy(mint_address: str, payment_sig: str) -> bool:
+    """Returns True if token passes cabal check."""
+    resp = requests.post(
+        "https://api.cabal-hunter.com/api/scan-cabal",
+        json={"mintAddress": mint_address},
+        headers={"X-Payment-Signature": payment_sig}
+    )
+    if resp.status_code != 200:
+        return False  # fail-safe: don't buy on error
+    data = resp.json()
+    # Block on: coordinated control, high score, bundled launch,
+    # or a deployer with a history of dead tokens
+    deployer_verdict = (data.get("deployer") or {}).get("verdict", "UNKNOWN")
+    return (
+        not data.get("is_controlled")
+        and data.get("cabal_score", 100) < 35
+        and not data.get("time_sync")
+        and deployer_verdict not in ("SERIAL_RUGGER", "SERIAL_LAUNCHER", "POOR_TRACK_RECORD")
+    )
+
+# In your bot's buy logic:
+if is_safe_to_buy(token_mint, my_payment_sig):
+    execute_swap(token_mint, sol_amount)
+else:
+    print(f"Cabal detected — skipping {token_mint}")
+```
+
+---
+
+## Interactive 3D Holder Map (Free)
+
+See exactly what the analysis found. Every real holder is a faceted crystal sized by its share of supply; wallets in the same cluster are joined by light beams, and the liquidity pool and locked supply sit apart in a wireframe vault because they cannot be sold. Drag to rotate, hover for the wallet, click through to Solscan:
+
+```
+https://api.cabal-hunter.com/map?mint=ANY_SOLANA_MINT
+```
+
+Free to view, in 9 languages. Share this URL when you catch a rug. Every crystal is clickable and links to Solscan for deep-dive research.
+
+---
+
+## Cabal-Hunter everywhere
+
+Same detection engine, wherever your stack lives:
 
-### Gate a buy in your agent
+- **`npx cabal-hunter-mcp`** — standalone MCP server for Claude · Cursor · VS Code · any MCP client: [cabal-hunter-mcp](https://github.com/paulf280-ui/cabal-hunter-mcp) · [npm](https://www.npmjs.com/package/cabal-hunter-mcp)
+- **ElizaOS plugin:** `npm i elizaos-plugin-cabal-hunter` — [plugin-cabal-hunter](https://github.com/paulf280-ui/plugin-cabal-hunter) · [npm](https://www.npmjs.com/package/elizaos-plugin-cabal-hunter)
+- **REST API + OpenAPI:** [api.cabal-hunter.com](https://api.cabal-hunter.com) · [/openapi.json](https://api.cabal-hunter.com/openapi.json)
 
-> "Before buying any token, call `check_cabal_risk` with the mint. If `recommendation` is `AVOID` or `cabal_score >= 65` or `honeypot_risk` is `HIGH`, skip the trade and say why."
+---
 
 ## Pricing
 
-- **250 scans/month per IP — free, no key.**
-- After that: **$9/month for Unlimited** (fair use), or pay-as-you-go at **$0.001 USDC per scan** (priced at cost). No signup, no card.
-- Prepaid key: send USDC, `POST /api/buy-key`, then set `CABAL_HUNTER_API_KEY` (sent as the `X-API-Key` header). Full details: [api.cabal-hunter.com/pricing](https://api.cabal-hunter.com/pricing).
+**First 250 scans every month are free** — per IP, no signup, no API key.
+
+After that, pick whatever matches how hard your bot works (priced at cost — it covers the Helius RPC behind each live on-chain trace):
+
+| Plan | Price | What you get |
+|------|-------|--------------|
+| **Unlimited** ⭐ | $9 USDC / month | Scan all you want — _fair use: 50,000/mo, more than any bot needs_ |
+| **Pay as you go** | $0.001 USDC / scan | Only what you use — prepaid or per-call, no commitment |
+
+Prepaid keys: send USDC once → `POST /api/buy-key` with the tx signature → use header `X-API-Key` on every scan. Or pay per-call via x402 (`X-Payment-Signature` header). No credit card, no account, no lock-in.
+
+**Does it pay for itself?** Work it out with your own numbers rather than ours: the Unlimited tier is $9 a month, so it pays for itself the first time it keeps you out of a position bigger than $9 that goes to zero. Whether that happens once a month or once a week depends on what you trade and how often — we are not going to invent an average for you.
+
+Payment is native on Solana — no credit card, no account, no subscription lock-in.
+
+---
+
+## Live dashboard badge
+
+Drop a live safety badge into your own bot's dashboard — two lines of HTML, and every token shows its verdict as it trades:
+
+```html
+<div class="cabal-hunter-badge" data-mint="YOUR_TOKEN_MINT"></div>
+<script src="https://api.cabal-hunter.com/widget.js" defer></script>
+```
+
+It renders the 0–100 score, the plain-English verdict, and the active flags (bundled launch, coordinated dump, whale concentration, serial-launcher deployer, honeypot). Add `data-refresh="120"` to re-scan live as you trade, and `data-api-key="..."` once you're past your free scans. Works anywhere — React, plain HTML, any site.
+
+---
+
+## API Reference
 
-## Configuration
+| Endpoint | Description | Auth |
+|----------|-------------|------|
+| `POST /api/scan-cabal` | Full cabal analysis | $0.001 USDC |
+| `GET /api/scan-cabal?mintAddress=` | GET version | $0.001 USDC |
+| `GET /map?mint=` | Interactive 3D holder map | Free |
+| `GET /api/cex-funding?mint=` | Per-exchange funding breakdown (which CEXes funded holders, % each) | Free |
+| `GET /api/trade-analysis?mint=` | Cohort PnL (Team/Snipers/Insiders) + wash-trading score + exit-liquidity price impact, one call | Free |
+| `POST /api/watch` | Register an emergency dump webhook for a mint (push on dump/rug start) | Free |
+| `GET /api/info` | Pricing, endpoints | Free |
 
-| Env var | Default | Purpose |
-|---|---|---|
-| `CABAL_HUNTER_API_KEY` | *(none)* | Prepaid key for unlimited / metered use (`X-API-Key`). |
-| `CABAL_HUNTER_API` | `https://api.cabal-hunter.com` | Override the API base URL. |
+### Emergency dump webhook (auto-exit)
 
-## Other ways to use Cabal-Hunter
+Instead of polling, let your bot subscribe to a token it holds — we push the moment a coordinated dump or liquidity drain starts:
 
-- **REST:** `curl "https://api.cabal-hunter.com/api/scan-cabal?mintAddress=<MINT>"` — [OpenAPI spec](https://api.cabal-hunter.com/openapi.json)
-- **ElizaOS plugin:** [`elizaos-plugin-cabal-hunter`](https://github.com/paulf280-ui/plugin-cabal-hunter) (`npm install elizaos-plugin-cabal-hunter`)
-- **Human?** Free interactive bubble map — wallets, Solscan receipts, live chart + trade links on one screen: [api.cabal-hunter.com/map](https://api.cabal-hunter.com/map)
+```bash
+curl -X POST https://api.cabal-hunter.com/api/watch \
+  -H "Content-Type: application/json" \
+  -d '{"mint":"YOUR_MINT","webhook_url":"https://your-bot.com/dump-alert"}'
+```
+
+Your endpoint receives:
+```json
+{ "event":"dump_detected", "mint":"...", "reason":"price −34% since last check",
+  "coordinated": true, "price_usd": 0.0001, "liquidity_usd": 4200,
+  "action":"consider_immediate_exit", "ts": 1781370000 }
+```
+| `GET /health` | Uptime check | Free |
+| `POST /mcp` | MCP tool endpoint | $0.001 USDC per call |
+
+---
+
+## Infrastructure
+
+- **RPC**: Dedicated Helius node (Frankfurt) — fastest Solana data available
+- **Hosting**: AWS EC2 Frankfurt — low latency for EU/global
+- **Analysis**: Real on-chain data — no scrapers, no caches of cached caches
+- **Uptime**: 99.9% target — monitored, auto-restart via systemd
+
+---
+
+## FAQ
+
+**What is a Solana cabal?**
+A group of wallets — often funded from the same source and buying in the same block — that quietly accumulate a large share of a token's supply before retail, then dump simultaneously into everyone who buys after launch.
+
+**How do I check if a Solana token is a rug?**
+Scan the mint with Cabal-Hunter (MCP, REST API, or the free 3D holder map). It traces holder funding back to shared sources, detects same-block bundle buys, flags serial-launcher deployers and live coordinated dumps, and returns an **Exit-Liquidity Risk** verdict: `LOW`, `ELEVATED`, or `HIGH`.
+
+**Is it free?**
+Yes — 250 scans/month per IP, with no signup or API key. Beyond that it's $0.001 USDC per scan — which just covers the Helius RPC cost of the live trace — paid natively on Solana.
+
+**Can AI trading agents use it?**
+Yes — that's the whole point. The MCP server (`api.cabal-hunter.com/mcp`) lets Claude, Cursor and ElizaOS agents call `check_cabal_risk(mintAddress)` automatically before any swap, and a REST API covers any other language.
+
+---
 
-## What it detects (why "contract-clean" misses it)
+## License
 
-A cabal is 15 fresh wallets — all funded from the same master wallet, all buying in the first seconds of launch — quietly accumulating 25–40% of supply before your bot sees the first candle. Contract clean. LP burned. Everything green. Then they dump, simultaneously, into your liquidity. Cabal-Hunter traces the funding graph on-chain and answers the only question that matters before you sign a swap: **are you the exit liquidity?**
+MIT — fork it, build on it, integrate it. If you build something with this, share it.
 
 ---
 
-MIT licensed. Powered by [Cabal-Hunter](https://api.cabal-hunter.com). This package is a thin MCP wrapper over the hosted API — the detection runs server-side against live Solana on-chain data (Helius RPC).
+*Built by [PF Capital](https://api.cabal-hunter.com) · Powered by Helius · Contact: api.cabal-hunter.com/api/info*

package/demo/python_demo.py

@@ -0,0 +1,74 @@
+"""
+Cabal-Hunter API demo — Python
+Checks a Solana token for coordinated wallet clusters before buying.
+
+First 250 scans/month are FREE — no signup, no API key, no payment.
+After that: $0.001 USDC per scan via X-Payment-Signature, or a prepaid
+key ($9/month unlimited, fair use 50k) via X-API-Key.
+
+Run:  python demo/python_demo.py
+"""
+
+import requests
+import json
+
+API = "https://api.cabal-hunter.com/api/scan-cabal"
+
+# Demo token — known cabal detected
+DEMO_MINT = "Axpzs7FEMYzpcfqVcDjDMQb2rsgMYVJADNpUZe7bpump"
+
+
+def check_token(mint: str) -> dict:
+    """
+    Query Cabal-Hunter for a token.
+    Free for the first 250 scans/month. After that, pass X-Payment-Signature
+    or X-API-Key.
+    """
+    resp = requests.post(API, json={"mintAddress": mint}, timeout=30)
+
+    if resp.status_code == 200:
+        return resp.json()
+
+    if resp.status_code == 402:
+        data = resp.json()
+        print("\n💳 Free quota exhausted. Payment required:")
+        print(f"   Send {data['payment']['amount_usdc']} USDC to {data['payment']['recipient']}")
+        print(f"   Memo: {data['payment']['memo_required']}")
+        print(f"   Then re-submit with: X-Payment-Signature: <your_tx_sig>")
+        return {}
+
+    raise RuntimeError(f"Unexpected {resp.status_code}: {resp.text}")
+
+
+def is_safe(report: dict) -> bool:
+    """Returns True if the token passes the cabal check."""
+    if not report:
+        return False  # fail-safe: treat no-response as unsafe
+    return not report.get("is_controlled") and report.get("cabal_score", 100) < 35
+
+
+if __name__ == "__main__":
+    print(f"Checking {DEMO_MINT[:8]}…\n")
+
+    report = check_token(DEMO_MINT)
+    if not report:
+        exit(1)
+
+    free_left = report.get("free_queries_remaining")
+    if free_left is not None:
+        print(f"✅ Free tier — {free_left} free scans remaining this month\n")
+
+    print(f"Token:       {report.get('token_name', '?')}")
+    print(f"Risk:        {report.get('risk')}")
+    print(f"Cabal Score: {report.get('cabal_score')}/100")
+    print(f"Verdict:     {report.get('verdict')}")
+    print(f"Analysis:    {report.get('analysis_time_ms')}ms  ({report.get('source')})")
+
+    clusters = report.get("coordinated_clusters", [])
+    if clusters:
+        print(f"\n⚠️  {len(clusters)} cluster(s) detected:")
+        for c in clusters:
+            print(f"   {c['wallet_count']} wallets from {c['master_short']} — {c['combined_pct']}% supply [{c['risk']}]")
+
+    print(f"\n{'🚫 SKIP — cabal detected' if not is_safe(report) else '✅ SAFE — no cabal detected'}")
+    print(f"\nVisual map: https://api.cabal-hunter.com/map?mint={DEMO_MINT}")

package/demo/typescript_demo.ts

@@ -0,0 +1,90 @@
+/**
+ * Cabal-Hunter API demo — TypeScript/Node.js
+ * Checks a Solana token for coordinated wallet clusters before buying.
+ *
+ * First 250 scans/month are FREE — no signup, no payment required.
+ * After that: $9/month unlimited, or $0.001 USDC per scan via x402
+ * (X-Payment-Signature header).
+ *
+ * Run:  npx tsx demo/typescript_demo.ts
+ */
+
+const API = "https://api.cabal-hunter.com/api/scan-cabal"
+
+// Demo token — known cabal detected
+const DEMO_MINT = "Axpzs7FEMYzpcfqVcDjDMQb2rsgMYVJADNpUZe7bpump"
+
+interface CabalReport {
+  token_name: string
+  risk: "HIGH" | "MEDIUM" | "CLEAN"
+  cabal_score: number
+  is_controlled: boolean
+  verdict: string
+  coordinated_clusters: Array<{
+    master_short: string
+    wallet_count: number
+    combined_pct: number
+    risk: string
+  }>
+  wallets_checked: number
+  analysis_time_ms: number
+  source: string
+  free_queries_remaining?: number
+}
+
+async function checkToken(mint: string, paymentSig?: string): Promise<CabalReport | null> {
+  const headers: Record<string, string> = { "Content-Type": "application/json" }
+  if (paymentSig) headers["X-Payment-Signature"] = paymentSig
+
+  const resp = await fetch(API, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({ mintAddress: mint }),
+  })
+
+  if (resp.status === 200) return resp.json() as Promise<CabalReport>
+
+  if (resp.status === 402) {
+    const data = await resp.json() as { payment: { amount_usdc: number; recipient: string; memo_required: string } }
+    console.log("\n💳 Free quota exhausted. Payment required:")
+    console.log(`   Send ${data.payment.amount_usdc} USDC to ${data.payment.recipient}`)
+    console.log(`   Memo: ${data.payment.memo_required}`)
+    console.log(`   Then re-submit with: X-Payment-Signature: <your_tx_sig>`)
+    return null
+  }
+
+  throw new Error(`Unexpected ${resp.status}: ${await resp.text()}`)
+}
+
+function isSafe(report: CabalReport): boolean {
+  return !report.is_controlled && report.cabal_score < 35
+}
+
+async function main() {
+  console.log(`Checking ${DEMO_MINT.slice(0, 8)}…\n`)
+
+  const report = await checkToken(DEMO_MINT)
+  if (!report) process.exit(1)
+
+  if (report.free_queries_remaining !== undefined) {
+    console.log(`✅ Free tier — ${report.free_queries_remaining} free scans remaining this month\n`)
+  }
+
+  console.log(`Token:       ${report.token_name}`)
+  console.log(`Risk:        ${report.risk}`)
+  console.log(`Cabal Score: ${report.cabal_score}/100`)
+  console.log(`Verdict:     ${report.verdict}`)
+  console.log(`Analysis:    ${report.analysis_time_ms}ms  (${report.source})`)
+
+  if (report.coordinated_clusters.length > 0) {
+    console.log(`\n⚠️  ${report.coordinated_clusters.length} cluster(s) detected:`)
+    for (const c of report.coordinated_clusters) {
+      console.log(`   ${c.wallet_count} wallets from ${c.master_short} — ${c.combined_pct}% supply [${c.risk}]`)
+    }
+  }
+
+  console.log(`\n${isSafe(report) ? "✅ SAFE — no cabal detected" : "🚫 SKIP — cabal detected"}`)
+  console.log(`\nVisual map: https://api.cabal-hunter.com/map?mint=${DEMO_MINT}`)
+}
+
+main().catch(console.error)

package/example_bot.py

@@ -0,0 +1,84 @@
+"""
+Example: Integrate Cabal-Hunter into a Solana trading bot.
+Checks for coordinated wallet clusters before executing any swap.
+Cost: 250 scans/month free, then $0.001 USDC per check (or $9/month
+unlimited). Pays for itself the first time it blocks a rug.
+"""
+
+import requests
+
+CABAL_HUNTER_URL = "https://api.cabal-hunter.com/api/scan-cabal"
+MAX_CABAL_SCORE  = 35    # block if score >= 35 (controlled token)
+
+
+def get_payment_instructions(mint: str) -> dict:
+    """Step 1: Get payment instructions from the API."""
+    resp = requests.post(CABAL_HUNTER_URL, json={"mintAddress": mint})
+    if resp.status_code == 402:
+        return resp.json()["payment"]
+    raise ValueError(f"Unexpected response: {resp.status_code}")
+
+
+def check_cabal(mint: str, payment_tx_sig: str) -> dict:
+    """Step 2: Submit analysis with payment proof."""
+    resp = requests.post(
+        CABAL_HUNTER_URL,
+        json={"mintAddress": mint},
+        headers={"X-Payment-Signature": payment_tx_sig},
+    )
+    if resp.status_code == 200:
+        return resp.json()
+    raise ValueError(f"Analysis failed: {resp.status_code} {resp.text}")
+
+
+def is_safe_to_buy(mint: str, payment_tx_sig: str) -> tuple[bool, str]:
+    """
+    Returns (safe, reason).
+    safe=True means proceed with the trade.
+    safe=False means the token has detected cabal risk — skip.
+    """
+    try:
+        result = check_cabal(mint, payment_tx_sig)
+        score  = result.get("cabal_score", 0)
+        risk   = result.get("risk", "CLEAN")
+
+        if result.get("is_controlled") or score >= MAX_CABAL_SCORE:
+            clusters = result.get("coordinated_clusters", [])
+            c = clusters[0] if clusters else {}
+            reason = (
+                f"CABAL DETECTED — Score {score}/100 — "
+                f"{c.get('wallet_count','?')} coordinated wallets holding "
+                f"{c.get('combined_pct','?')}% of supply"
+            )
+            return False, reason
+
+        return True, f"CLEAN — Score {score}/100 — {result.get('wallets_checked','?')} wallets traced"
+
+    except Exception as e:
+        # Fail safe: skip trade on any error
+        return False, f"Cabal check failed ({e}) — skipping trade as precaution"
+
+
+# ── Example usage ─────────────────────────────────────────────────────────────
+
+if __name__ == "__main__":
+    token_mint = "PASTE_TOKEN_MINT_HERE"
+
+    # Step 1: Get payment instructions
+    print(f"Checking {token_mint[:8]}…")
+    payment = get_payment_instructions(token_mint)
+    print(f"  → Send {payment['amount_usdc']} USDC to {payment['recipient']}")
+    print(f"  → Memo: {payment['memo_required']}")
+
+    # Step 2: You send the USDC (via your wallet SDK), get the tx sig
+    payment_sig = input("Paste your transaction signature: ").strip()
+
+    # Step 3: Check result
+    safe, reason = is_safe_to_buy(token_mint, payment_sig)
+    print(f"\n{'✅ SAFE' if safe else '🚫 BLOCKED'}: {reason}")
+
+    if safe:
+        print("Proceeding with swap…")
+        # execute_swap(token_mint, sol_amount)
+    else:
+        print("Trade cancelled — protecting your capital.")

package/glama.json

@@ -0,0 +1,4 @@
+{
+  "$schema": "https://glama.ai/mcp/schemas/server.json",
+  "maintainers": ["paulf280-ui"]
+}

package/package.json

@@ -1,58 +1,33 @@
 {
   "name": "cabal-hunter-mcp",
-  "version": "0.1.0",
-  "description": "MCP server for on-chain Solana cabal & rug detection — exit-liquidity risk verdict, funding-cluster + same-block-bundle + coordinated-dump detection, serial-rug deployer history, and honeypot check for any token mint. Run with npx, no API key. 250 free scans/month.",
+  "version": "1.0.2",
+  "description": "MCP server for Cabal-Hunter \u2014 Solana token rug & cabal detection for AI agents. Wallet clusters, same-block bundles, deployer track record with peak market caps, honeypot and authority traps. 250 free scans/month, no signup.",
   "type": "module",
   "bin": {
-    "cabal-hunter-mcp": "index.js"
+    "cabal-hunter-mcp": "server/index.mjs"
+  },
+  "main": "server/index.mjs",
+  "scripts": {
+    "start": "node server/index.mjs"
   },
-  "main": "index.js",
-  "files": [
-    "index.js",
-    "README.md",
-    "LICENSE"
-  ],
   "engines": {
     "node": ">=18"
   },
-  "scripts": {
-    "start": "node index.js"
-  },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.0.0"
+    "@modelcontextprotocol/sdk": "^1.7.0"
   },
   "keywords": [
     "mcp",
-    "model-context-protocol",
-    "mcp-server",
     "solana",
-    "rug-check",
     "rug-detection",
-    "rugcheck",
-    "cabal-detection",
-    "memecoin",
-    "pump-fun",
-    "pumpfun",
-    "token-safety",
-    "honeypot-detection",
-    "exit-liquidity",
-    "trading-bot",
-    "ai-agent",
-    "ai-agents",
-    "web3",
-    "defi",
-    "claude",
-    "cursor",
-    "elizaos"
+    "cabal",
+    "trading",
+    "model-context-protocol"
   ],
   "license": "MIT",
-  "author": "Cabal-Hunter (https://api.cabal-hunter.com)",
-  "homepage": "https://api.cabal-hunter.com",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/paulf280-ui/cabal-hunter-mcp.git"
+    "url": "git+https://github.com/paulf280-ui/solana-safe-sniper-mcp-template.git"
   },
-  "bugs": {
-    "url": "https://github.com/paulf280-ui/cabal-hunter-mcp/issues"
-  }
+  "homepage": "https://api.cabal-hunter.com"
 }

package/server/index.mjs

@@ -0,0 +1,125 @@
+#!/usr/bin/env node
+/**
+ * Cabal-Hunter — local stdio MCP server.
+ *
+ * A thin Model Context Protocol server that exposes one tool, `check_cabal_risk`,
+ * and proxies to the hosted Cabal-Hunter API (https://api.cabal-hunter.com).
+ * Drop it into any MCP client (Claude Desktop, Cursor, ElizaOS) to give an agent
+ * a pre-trade safety check that catches coordinated wallet cabals, same-block
+ * Jito bundles, the dev's launch track record (peak market cap per past token +
+ * pump-and-dump history) and live coordinated dumps on any Solana mint before it
+ * signs a swap.
+ *
+ * Free tier: 250 scans/month per IP, no signup. Beyond that it is $9/month
+ * unlimited (fair use), or $0.001 USDC per scan via x402 on Solana — when a
+ * scan needs payment the API returns HTTP 402 with the payment instructions,
+ * which this tool surfaces to the caller.
+ *
+ * Uses the low-level Server API + JSON-Schema tool definitions for maximum
+ * compatibility across @modelcontextprotocol/sdk versions.
+ */
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  ListToolsRequestSchema,
+  CallToolRequestSchema,
+} from "@modelcontextprotocol/sdk/types.js";
+
+const API_BASE = process.env.CABAL_HUNTER_API || "https://api.cabal-hunter.com";
+const SCAN_URL = `${API_BASE}/api/scan-cabal`;
+
+const server = new Server(
+  { name: "cabal-hunter", version: "1.0.0" },
+  { capabilities: { tools: {} } }
+);
+
+const CHECK_CABAL_RISK = {
+  name: "check_cabal_risk",
+  description:
+    "Scan a Solana token mint for coordinated wallet cabals, same-block Jito " +
+    "bundle buys, the dev's launch track record (peak market cap per past token " +
+    "+ pump-and-dump history) and live coordinated dumps. Returns an " +
+    "Exit-Liquidity Risk verdict (cabal_score 0-100, risk level, is_controlled, " +
+    "coordinated wallet clusters) so a trading agent can decide whether it is " +
+    "about to become exit liquidity BEFORE it signs a swap. Works on pump.fun, " +
+    "PumpSwap and Raydium tokens.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      mintAddress: {
+        type: "string",
+        description: "The Solana token mint address (base58) to scan.",
+      },
+    },
+    required: ["mintAddress"],
+  },
+};
+
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools: [CHECK_CABAL_RISK],
+}));
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  if (request.params.name !== "check_cabal_risk") {
+    throw new Error(`Unknown tool: ${request.params.name}`);
+  }
+  const mintAddress = request.params.arguments?.mintAddress;
+  if (!mintAddress || typeof mintAddress !== "string") {
+    return {
+      isError: true,
+      content: [{ type: "text", text: "mintAddress is required (base58 mint string)." }],
+    };
+  }
+
+  try {
+    const resp = await fetch(SCAN_URL, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ mintAddress }),
+    });
+
+    // x402: payment required — surface the instructions rather than failing.
+    if (resp.status === 402) {
+      const body = await resp.json().catch(() => ({}));
+      return {
+        content: [
+          {
+            type: "text",
+            text:
+              "Payment required (x402). Free tier exhausted — this scan costs " +
+              "$0.02 USDC on Solana.\n\n" +
+              JSON.stringify(body.payment || body, null, 2),
+          },
+        ],
+      };
+    }
+
+    if (!resp.ok) {
+      const text = await resp.text().catch(() => "");
+      return {
+        isError: true,
+        content: [{ type: "text", text: `Scan failed: HTTP ${resp.status} ${text}` }],
+      };
+    }
+
+    const data = await resp.json();
+    return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+  } catch (err) {
+    return {
+      isError: true,
+      content: [{ type: "text", text: `Scan error: ${err?.message || String(err)}` }],
+    };
+  }
+});
+
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  // stdio transport keeps the process alive; log to stderr so stdout stays clean.
+  console.error("cabal-hunter MCP server running on stdio");
+}
+
+main().catch((err) => {
+  console.error("fatal:", err);
+  process.exit(1);
+});

package/index.js

@@ -1,95 +0,0 @@
-#!/usr/bin/env node
-/**
- * cabal-hunter-mcp — local MCP server for on-chain Solana cabal/rug detection.
- *
- * Exposes one tool, `check_cabal_risk`, that scans any Solana token mint and
- * returns an exit-liquidity risk verdict (SAFE / REVIEW / AVOID), a 0-100 cabal
- * score, funding-cluster + same-block-bundle + coordinated-dump detection,
- * serial-rug deployer history, and a honeypot (freeze / Token-2022) check.
- *
- * It is a thin stdio wrapper over the hosted Cabal-Hunter API
- * (https://api.cabal-hunter.com) so any MCP client — Claude Desktop, Claude
- * Code, Cursor, VS Code, ElizaOS — can run it with `npx cabal-hunter-mcp`.
- *
- * Free tier: 250 scans/month per IP, no signup, no key. To use a prepaid key
- * (e.g. $9/mo unlimited), set CABAL_HUNTER_API_KEY.
- */
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import {
-  ListToolsRequestSchema,
-  CallToolRequestSchema,
-} from "@modelcontextprotocol/sdk/types.js";
-
-const API = (process.env.CABAL_HUNTER_API || "https://api.cabal-hunter.com").replace(/\/+$/, "");
-const API_KEY = process.env.CABAL_HUNTER_API_KEY || "";
-
-const TOOL = {
-  name: "check_cabal_risk",
-  description:
-    "Real-time on-chain coordinated-wallet (cabal) and rug detection for any " +
-    "Solana token mint. One call returns an Exit-Liquidity Risk verdict " +
-    "(SAFE | REVIEW | AVOID), a 0-100 cabal score, funding-cluster detection " +
-    "(top holders funded by the same source), same-block Jito-bundle detection, " +
-    "coordinated-dump detection, serial-rug deployer history (e.g. 'launched 14, " +
-    "13 dead'), a honeypot check (freeze authority + Token-2022 traps), and " +
-    "on-chain evidence transactions for every flag. Use it before an agent buys a " +
-    "pump.fun / PumpSwap / Raydium token to answer: are you the exit liquidity? " +
-    "Free: 250 scans/month, no API key required.",
-  inputSchema: {
-    type: "object",
-    properties: {
-      mint: {
-        type: "string",
-        description:
-          "The Solana token mint (contract) address to scan, e.g. " +
-          "DezXAZ8z7PnrnRJjz3wXBoRgixCa6xjnB7YaB1pPB263",
-      },
-    },
-    required: ["mint"],
-  },
-};
-
-const server = new Server(
-  { name: "cabal-hunter", version: "0.1.0" },
-  { capabilities: { tools: {} } }
-);
-
-server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: [TOOL] }));
-
-server.setRequestHandler(CallToolRequestSchema, async (req) => {
-  const { name, arguments: args } = req.params;
-  if (name !== TOOL.name) {
-    return { content: [{ type: "text", text: `Unknown tool: ${name}` }], isError: true };
-  }
-  const mint = String(args?.mint || "").trim();
-  if (!mint) {
-    return {
-      content: [{ type: "text", text: "Error: 'mint' (a Solana token mint address) is required." }],
-      isError: true,
-    };
-  }
-  const url = `${API}/api/scan-cabal?mintAddress=${encodeURIComponent(mint)}`;
-  const headers = { Accept: "application/json" };
-  if (API_KEY) headers["X-API-Key"] = API_KEY;
-  try {
-    const res = await fetch(url, { headers });
-    const text = await res.text();
-    if (!res.ok) {
-      return {
-        content: [{ type: "text", text: `Cabal-Hunter API error ${res.status}: ${text.slice(0, 800)}` }],
-        isError: true,
-      };
-    }
-    return { content: [{ type: "text", text }] };
-  } catch (e) {
-    return {
-      content: [{ type: "text", text: `Request to Cabal-Hunter failed: ${e?.message || String(e)}` }],
-      isError: true,
-    };
-  }
-});
-
-const transport = new StdioServerTransport();
-await server.connect(transport);
-console.error(`cabal-hunter MCP server running on stdio → ${API}`);