stuntman

mcp
Guvenlik Denetimi
Uyari
Health Uyari
  • License — License: Apache-2.0
  • Description — Repository has a description
  • Active repo — Last push 0 days ago
  • Low visibility — Only 6 GitHub stars
Code Gecti
  • Code scan — Scanned 12 files during light audit, no dangerous patterns found
Permissions Gecti
  • Permissions — No dangerous permissions requested

Bu listing icin henuz AI raporu yok.

SUMMARY

The stunt double for every provider your app calls: SMS, WhatsApp, e-mail, storage, queues, identity, secrets and any HTTP API. Built for coding agents, over MCP or HTTP.

README.md

Stuntman: watch your coding agent prove its own fix

Stuntman

The stunt double for every provider your app calls.
SMS, WhatsApp, email, mailboxes, storage, file servers, queues, Kafka, Pub/Sub, identity, secrets, AI models,
product analytics, webhooks and any HTTP API,
answering like the real thing, so you and your coding agents can test the hard cases end to end.

Get started · Agents · Providers · Failures on cue · Plugins · Tool reference

Status: early. Stuntman is a working name. It runs and is used every day against a real product's staging environment,
but the plugin format may still change and there is no sign-in yet. Read Security
before you put it anywhere other people can reach.

Set it up with one prompt

Paste this into your coding agent (Claude Code, Codex, Gemini CLI, OpenCode, Cursor, GitHub Copilot…):

Set up Stuntman for this project: read https://edivanteixeira.github.io/stuntman/agent-setup.md and follow it step by step.

The agent asks which language you prefer, starts Stuntman with Docker, finds every provider your project calls,
shows you each change before making it, points your local configuration at Stuntman, proves nothing still reaches a
real provider and ends with every link ready. The guide it follows is open to read.


Why

Staging talks to providers you do not control. That costs money, sends real messages, and, worst of all,
never shows you the cases that break production: the SMS that never arrives, the user who answers on WhatsApp,
the upload that fails twice, the token that expires mid-flow.

Stuntman takes the providers' place. Your app keeps its code and every other setting; only the base URLs change.
Stuntman answers with the provider's own paths, bodies and status codes, keeps their state, sends their
callbacks back and fails exactly when you ask it to.

Built for agents that test their own work

The loop an agent runs on its own: read the code, set up Stuntman, change the code, run the real flow, provoke failures, read what the app sent, check the result

Every action in Stuntman is a tool: 382 of them, each one both an MCP tool and an HTTP route.
Claude Code, Codex, Gemini CLI, OpenCode, Cursor, GitHub Copilot or a plain test script can:

  1. Set it up. Find the providers your app calls, install the matching plugins, point the base URLs at Stuntman.
  2. Provoke. Make the next send fail with a 500, bounce an email, expire every token, answer as the user.
  3. Read. See every call your app made, in the provider's words, with its retries and callbacks.
  4. Check. Confirm against the timeline, not against the agent's summary, and confirm nothing leaked to a real provider.
you    Make contract uploads fail twice with a 503, then tell me whether acme-api recovers.
agent  create_rule        {"when": {"op": "put", "path": "contracts/**"}, "then": {"respond": "503"}, "how_often": {"first": 2}}
agent  wait_for_object    {"container": "documents", "prefix": "contracts/nda-acme"}   → 408: nothing stored
agent  Two 503s, then acme-api gave up. The retry limit is the bug. Fixing it and running again.
agent  wait_for_object    → nda-acme-signed.pdf stored, on the third attempt
agent  set_rule_enabled   {"enabled": false}

Illustrative session with synthetic data. Tool names and argument shapes are real; some arguments are left out.

→ Connect your agent

Quick start

docker run -d --name stuntman \
  -p 127.0.0.1:8025:8025 -p 127.0.0.1:2525:2525 -p 127.0.0.1:8028:8028 \
  -v stuntman-data:/data edivanteixeira/stuntman

open http://localhost:8025          # the web UI; the HTTP API is /api, MCP is /mcp

The image is on Docker Hub as edivanteixeira/stuntman
(linux/amd64 and linux/arm64). Publish more ports for more lines (-p 127.0.0.1:8085:8085 for Pub/Sub,
-p 127.0.0.1:61616:61616 for ActiveMQ; all of them are in Configuration), or run every port at once with Docker Compose:
cd engine && docker compose up -d.

Point your app's provider URLs at it (examples):

Provider Point it at
WhatsApp Cloud API (Meta Graph) http://localhost:8025/whatsapp
SendGrid http://localhost:8025/sendgrid
SMTP localhost:2525
Any HTTP API (plugins) http://localhost:8028/<service>
Azure Blob http://127.0.0.1:10000/<account>
Amazon S3 http://127.0.0.1:9000 (path style)
OpenTelemetry http://localhost:4318 (or gRPC :4317)
OpenAI, Anthropic, Gemini… http://localhost:8025/openai/v1, …/anthropic, …/gemini
Kafka localhost:9092 (Schema Registry http://localhost:8081)
Google Cloud Pub/Sub PUBSUB_EMULATOR_HOST=localhost:8085
ActiveMQ (OpenWire) tcp://localhost:61616 (NMS: activemq:tcp://localhost:61616)

Connect Claude Code:

claude mcp add --transport http stuntman http://localhost:8025/mcp

→ Full getting started guide · Configuration and ports

What it stands in for

Line Providers today You can provoke
HTTP APIs Any REST, GraphQL or SOAP API, described as a YAML plugin: OAuth2, Basic, session cookies, mTLS (ICP-Brasil e-CNPJ too), browser steps, streamed answers, signed webhooks, idempotency keys, an MCP server. Made from an OpenAPI spec, a WSDL, WireMock mappings, or by recording the real provider. 45 plugins in the catalog named answers, SOAP faults, XML signatures, latency, 5xx, reset, timeout, cut streams, expired tokens, badly signed or repeated webhooks, billing and rate limits
AI models OpenAI, Azure OpenAI, Anthropic, Gemini, OpenRouter, DeepSeek: chat, Responses, messages, embeddings, streaming, tool calls 429, 500, 529, content filter, cut by max_tokens, broken tool arguments, slow or cut streams; spend per provider
SMS Zenvia API v2 500, 400, reset, empty reply, timeout; the person texts back, STOP / START
WhatsApp Meta WhatsApp Cloud API (Graph) 500, 400, connection failures, expired tokens, user replies, badly signed or replayed webhooks
Email SMTP (STARTTLS) and SendGrid v3, signed event webhook; IMAP and POP3 mailboxes the app reads bounce, defer, drop, hold; open, click, spam report, unsubscribe events; logins refused, mailbox busy, dropped fetches
Storage Azure Blob (SharedKey, SAS) and Amazon S3 (SigV4) 503 on the first N attempts, 403/404, slow reads, bad MD5, expired or tampered links, lost or duplicated events
Files FTP, FTPS and SFTP servers over shared folders logins refused, disk full, permission denied, transfers cut or slow, a changed host key
Messaging Azure Service Bus and RabbitMQ over AMQP, RabbitMQ management API; ActiveMQ "Classic" over OpenWire (queues, topics, local and XA transactions, durable subscriptions, selectors, exclusive and priority consumers, message groups, scheduled delivery, ActiveMQ.DLQ, advisories) lost locks, duplicates, held, dropped, dead-lettered or out-of-order messages, refused or busy namespace; refused logins, dropped connections, slow dispatch, lost acks, failed commits
Streams Kafka (SASL, consumer groups) and Confluent Schema Registry with Avro leader not available, SASL refused, slow fetches, duplicates, rebalances, registry down
Pub/Sub Google Cloud Pub/Sub emulator over gRPC (StreamingPull, ack deadlines, ordering keys, dead-letter topics, schemas, snapshots and seek, filters, push, BigQuery, Cloud Storage and Bigtable subscriptions, import topics, JavaScript and AI inference transforms, exactly-once) unavailable, deadline exceeded, quota exhausted, topic not found, slow publishes, duplicate deliveries
Identity OIDC / OAuth2 (Microsoft Entra ID, Google, Okta, generic OIDC, password grant), SAML 2.0, LDAP, Bot Framework MFA, consent, user cancels, wrong tenant, expired tokens, bad signature, IdP down, broken discovery or JWKS, locked accounts
Secrets Azure Key Vault (secrets, keys, certificates) and managed identity 403, 404, 429, disabled, slow, expired or untrusted certificates, wrong signatures
Webhook inboxes Endpoints your app sends its own webhooks to 200, 500, timeout, hang, delay, fail N times then succeed, signature checks
Product events PostHog, Segment, Mixpanel, GA4 Measurement Protocol, with tracking plans 400, 413, 429, slow, half the events lost; personal data flagged
Telemetry OpenTelemetry (OTLP logs, traces, metrics), GELF, StatsD a collector that refuses, rejects, throttles, slows down or drops half

→ Providers in detail · Every failure you can provoke

See it

The timeline: every call as a sentence in the provider's words Timeline. Every call as a sentence, who made it and what was provoked. A storage rule: fail the first two uploads, then answer normally Rules. Which requests, what to answer, how often. Tried before saved.
The route editor with the plugin YAML beside it Plugins. Edit a route in the UI; the YAML beside it stays the source of truth. Environments: STG-A, STG-B, STG-C and a pull-request copy that expires Environments. One process, many environments; clone one per pull request.

Screens use synthetic data.

Principles

  1. The plugin is the product. Everything a provider does lives in one installable file.
  2. Text is the source of truth. The web UI is a second way to edit the same YAML, never a separate copy.
  3. The provider's words first. Raw HTTP is one click away.
  4. Provoking is as easy as watching.
  5. Safe by default. A plugin cannot reach the network or the disk unless it declares it.

Documentation

Guide What it covers
Getting started Run it, point your app, connect an agent, ask for the hard case
Agents MCP and HTTP, client-by-client setup, the loop, tools by intent
Providers Each line: what it speaks, what it keeps, how to point your app at it
Failures on cue Rules, forced answers and every provocation, line by line
Timeline and proof Reading what your app did; unmatched calls; telemetry
Plugins The YAML format, expressions, installing, validating
OpenAPI specs A provider from its OpenAPI or Swagger spec: routes, answers, body checks
Recording Record the real provider's sandbox and turn the calls into a plugin
SOAP services A provider from its WSDL: operations, faults, WS-Security, XML signatures, ICP-Brasil certificates, callbacks
WireMock mocks WireMock mappings made into plugins: matchers, scenarios, response templates
The clock Move an environment's time forward; scheduled webhooks
Environments One environment per branch: clone, pause, expire, route requests
Configuration Environment variables, ports, Docker, data layout
Security What is and is not protected today
Tool reference All 382 tools, generated from the source

How it is built

A single Rust process serves every environment: the web UI (Leptos, compiled to WebAssembly), the HTTP API,
MCP over streamable HTTP and each provider on its own port. State lives in SQLite per environment;
configuration lives in YAML files you can read, diff and commit. Each provider is a crate that implements one
module interface, so adding a provider never touches the others. See engine/README.md.

engine/
  crates/core       shared: storage, tools (MCP tool = HTTP route), signed callbacks, live events
  crates/server     wires the modules; one router per environment; /api, /mcp, the web UI
  crates/apis       the HTTP plugin engine (YAML + expressions) — plugins/ is the catalog
  crates/email      SMTP, SendGrid, IMAP, POP3   crates/sms        SMS (Zenvia)
  crates/whatsapp   WhatsApp Cloud API           crates/storage    Azure Blob and S3
  crates/messaging  Service Bus, RabbitMQ, AMQ   crates/identity   OIDC, SAML, LDAP, Bot Framework
  crates/keyvault   Key Vault, managed id.       crates/webhook    webhook inboxes
  crates/telemetry  OTLP, GELF, StatsD           crates/ai         AI model APIs
  crates/events     product analytics            crates/files      FTP, FTPS, SFTP
  crates/streams    Kafka, Schema Registry       crates/pubsub     Google Cloud Pub/Sub
  web/              the web UI (Leptos)

Contributing

The most valuable contribution is a plugin for a provider you know well. Start with
Plugins and CONTRIBUTING.md.

License

Apache License 2.0. See LICENSE.

Yorumlar (0)

Sonuc bulunamadi