Skip to main content
Glama
domain-security-mcp-server

domain-security-mcp-server

by OrtaMarco

domain-security-mcp-server

An MCP server that lets an AI agent audit the email and domain security of any domain — SPF, DKIM, DMARC, MTA-STS, TLS-RPT, BIMI, DNSSEC, DNS, TLS/SSL and WHOIS — in plain language. No API keys required.

ci npm MCP TypeScript License: MIT

Built on the v2 MCP SDK: the server speaks the 2026-07-28 protocol revision and keeps accepting 2025-era clients (Claude Desktop, Claude Code, Cursor) from the same factory — the era is negotiated per connection, so there is nothing to configure on either side.

Ask Claude "Is acme.com protected against email spoofing?" and it runs a full authentication audit and hands you a graded report with prioritised fixes — instead of you pasting a domain into five different web tools.

> Is ortamarco.me protected against email spoofing?

  email_auth_audit(domain="ortamarco.me")

  Grade: A (95/100) · MX: present
  ✅ SPF ends in '-all' (hard fail). 3/10 DNS lookups.
  ✅ DMARC policy is enforced ('p=reject').
  ✅ DKIM key found for selector: google.
  Top recommendation: add a TLS-RPT record for delivery-failure reports.

Why this exists

The email-security ecosystem is full of single-purpose web checkers (SPF here, DMARC there, WHOIS somewhere else) and the few MCP equivalents are locked behind paid API tokens. This server brings the whole deliverability & domain-security toolkit to any MCP client, key-free, with one headline workflow tool that does the synthesis for you.

It is the agent-facing companion to the network tools at ortamarco.me and shares the same battle-tested core (public-resolver DNS, host validation, timeouts).

Related MCP server: DnsGuard

Tools

Tool

What it does

email_auth_audit ⭐

One-call SPF + DKIM + DMARC + MX audit → 0–100 score, A–F grade, prioritised fixes

spf_check

Parse SPF; recursively count DNS lookups vs the RFC 7208 limit of 10; flag +all/?all

dmarc_check

Parse the DMARC record (every tag is returned) and flag a missing or invalid p, p=none, no rua and pct under 100

dkim_check

Probe <selector>._domainkey keys (supply selectors or use common ones)

mta_sts_check

Validate the _mta-sts TXT and the .well-known/mta-sts.txt policy + mode

tls_rpt_check

Check the _smtp._tls TLS-RPT record

bimi_check

Check the default._bimi BIMI record

dnssec_check

DS/DNSKEY presence + DNSSEC AD validation flag (via DoH)

dns_lookup

All record types (A/AAAA/CNAME/MX/NS/TXT/SOA) via public resolvers

ssl_certificate

TLS cert issuer, validity window, days-to-expiry, SANs, fingerprint

whois_lookup

Registrar, dates, name servers, status (raw port-43 WHOIS, IANA-resolved)

reverse_dns

PTR records for an IP

ip_geolocation

Offline IP geolocation (DB-IP Lite) + reverse DNS

mx_lookup

Mail servers (MX) with priority and resolved IPs

caa_check

Which CAs may issue TLS certificates (CAA records)

blacklist_check

IP/domain against open-access email DNSBLs

dns_propagation

Compare a record across 5 public resolvers worldwide

http_security_headers

Grade a site's HSTS, CSP, X-Content-Type-Options, X-Frame-Options, Referrer-Policy, Permissions-Policy and COOP (an HSTS max-age=0 earns nothing)

analyze_email_headers

Parse raw headers → SPF/DKIM/DMARC verdicts + Received hop chain with delays

Every tool is read-only, declares an outputSchema and returns structuredContent (validated by the SDK) alongside human-readable Markdown (default) or JSON (response_format="json"), plus actionable error messages.

Install

Requires Node.js 20.18+. Nothing to clone — every MCP client can run it with npx.

Use it with Claude Code

claude mcp add domain-security -- npx -y domain-security-mcp-server

Use it with Claude Desktop or Cursor

Add to claude_desktop_config.json (or ~/.cursor/mcp.json) — see examples/:

{
  "mcpServers": {
    "domain-security": {
      "command": "npx",
      "args": ["-y", "domain-security-mcp-server"]
    }
  }
}

On Windows use "command": "cmd" with "args": ["/c", "npx", "-y", "domain-security-mcp-server"]. Restart the client, then ask: "Audit the email security of stripe.com."

Self-host (HTTP transport)

The same server speaks stateless Streamable HTTP for remote or multi-client use. One endpoint serves both protocol eras and there is no session state, so no Mcp-Session-Id header is issued or expected.

TRANSPORT=http npx -y domain-security-mcp-server
# POST JSON-RPC to http://127.0.0.1:3000/mcp   ·   health at /healthz

It is safe by default: it binds to 127.0.0.1 and only accepts localhost Host and Origin headers, which blocks DNS-rebinding attacks from a web page. To expose it — for example behind Coolify or Traefik — opt in explicitly:

Variable

Default

Purpose

TRANSPORT

stdio

http to serve Streamable HTTP

PORT

3000

Listening port

HOST

127.0.0.1

Bind address; 0.0.0.0 to accept remote connections

ALLOWED_HOSTS

—

Comma-separated hostnames the Host header may carry (e.g. mcp.example.com)

ALLOWED_ORIGINS

—

Comma-separated origins allowed to call from a browser

MCP_AUTH_TOKEN

—

If set, every request needs Authorization: Bearer <token>

Binding to a non-loopback address without ALLOWED_HOSTS or MCP_AUTH_TOKEN works, but the server says so on stderr. With Docker (the image sets HOST=0.0.0.0):

docker build -t domain-security-mcp .
docker run -p 3000:3000 -e ALLOWED_HOSTS=mcp.example.com -e MCP_AUTH_TOKEN=change-me domain-security-mcp

Security

The tools reach out to hosts that the caller names, so every outbound connection is screened against server-side request forgery:

  • Private, loopback, link-local (cloud metadata), shared, multicast and reserved addresses are refused in every spelling, including IPv4 embedded in IPv6 ([::ffff:169.254.169.254]).

  • The check happens at connect time, on the address the socket is actually about to use, so DNS rebinding and names only an internal resolver knows are refused too. Redirects are followed by hand and every hop is re-checked.

  • Response bodies, redirects, WHOIS referrals and every network call are capped and time-limited.

Found a problem? Please open a private security advisory.

Develop

npm run dev      # tsx watch (stdio)
npm run inspect  # open the MCP Inspector against the built server
npm run build     # type-check + emit dist/
npm run typecheck # type-check only
npm test          # offline unit tests: SSRF guard, SPF/DMARC/DKIM scoring,
                  # header parsing, HTTP transport defaults
npm run smoke     # call all 19 tools on BOTH protocol eras and validate
                  # structuredContent against each tool's outputSchema

evals/ holds a 10-question LLM evaluation set (stable, verifiable) and instructions for running it — see evals/README.md.

How it works

src/
├── index.ts        # transport selection (stdio | http), v2 SDK entry points
├── server.ts       # factory: registers every tool on one McpServer
├── core/           # pure logic, no MCP coupling — reusable & testable
│   ├── validate.ts # input validation and the address classifier
│   ├── netguard.ts # connect-time SSRF guard, redirect-safe fetch, capped bodies
│   ├── dns.ts      # public-resolver DNS + DoH client
│   ├── net.ts      # MX, CAA, DNSBL and propagation checks
│   ├── tls.ts      # certificate inspection and trust
│   ├── whois.ts    # port-43 WHOIS with IANA/registrar referral
│   ├── http.ts     # security-header grading
│   ├── geoip.ts    # offline IP geolocation on DB-IP Lite (each file read on first use)
│   ├── email-headers.ts  # raw header parsing and hop timing
│   └── email-auth.ts  # SPF/DKIM/DMARC/MTA-STS/TLS-RPT/BIMI/DNSSEC + scoring
└── tools/          # thin MCP wrappers (Zod schemas, descriptions, formatting)

The core/ layer is deliberately free of any MCP types, so the exact same logic powers both this server and the web tools on ortamarco.me.

Credits

IP Geolocation by DB-IP. ip_geolocation uses the free DB-IP "IP to City Lite" database, licensed under CC BY 4.0 and installed as the @ip-location-db/dbip-city-mmdb package; the credit also appears in the tool's description and Markdown output. The database has no time zone, so time_zone is estimated from the coordinates with @photostructure/tz-lookup (CC0).

License

MIT © Marco Orta

Available Tools

19 tools
analyze_email_headersEmail Header AnalyzerA
Read-onlyIdempotent

Parse raw email headers and report the SPF/DKIM/DMARC verdicts (from Authentication-Results), key fields (From, Subject, Date, Message-ID, Return-Path) and the Received hop chain with per-hop delays and total transit time.

Args:

  • headers (string): the raw email headers.

  • response_format ('markdown' | 'json'): output format (default 'markdown').

Returns: { auth{spf,dkim,dmarc}, fields{}, hops[{index,from,by,date,delaySec}], totalSec }.

Example: paste the headers from "Show original" in Gmail to trace a message's path and authentication.

Inputs: headers (required), response_format. Returns: auth, hops, fields, totalSec

bimi_checkBIMI CheckA
Read-onlyIdempotent

Check a domain's BIMI record (default._bimi. TXT), which points to the brand logo (and optional VMC) displayed next to authenticated mail. BIMI requires an enforced DMARC policy to take effect.

Args:

  • domain (string): the domain to check.

  • response_format ('markdown' | 'json'): output format (default 'markdown').

Returns: { found, record, findings[] }.

Example: "Does cnn.com have BIMI set up?" -> bimi_check(domain="cnn.com").

Inputs: domain (required), response_format. Returns: found, domain, record, findings

blacklist_checkDNSBL Blacklist CheckA
Read-onlyIdempotent

Check whether an IPv4 address (or a domain's A records) appears on email DNS blocklists (DNSBLs). Only open-access lists are queried (SpamCop, UCEPROTECT-1, DroneBL, s5h); Spamhaus and Barracuda refuse public-resolver queries and are excluded.

Args:

  • query (string): an IPv4 address or a domain.

  • response_format ('markdown' | 'json'): output format (default 'markdown').

Returns: { ips[], listedCount, checked, results[{ip, hits[{list, listed, reason, error}]}], note }. A list that did not answer carries an error and is not counted as clean.

Example: "Is 203.0.113.5 blacklisted?" -> blacklist_check(query="203.0.113.5").

Inputs: query (required), response_format. Returns: ips, note, query, checked, +2 more

caa_checkCAA Record CheckA
Read-onlyIdempotent

Check a domain's CAA (Certification Authority Authorization) records — which CAs are allowed to issue TLS certificates for it. Absence means any CA may issue.

Args:

  • domain (string): the domain to check.

  • response_format ('markdown' | 'json'): output format (default 'markdown').

Returns: { found, issue[], issuewild[], iodef[] }.

Example: "Which CAs can issue certs for google.com?" -> caa_check(domain="google.com").

Inputs: domain (required), response_format. Returns: found, iodef, issue, domain, +1 more

dkim_checkDKIM Record CheckA
Read-onlyIdempotent

Look up DKIM public keys at ._domainkey.. Because DKIM selectors are arbitrary and undiscoverable, you should pass the selector(s) your mail provider uses for a definitive answer; otherwise a curated list of common selectors is probed and a miss is inconclusive.

Args:

  • domain (string): the domain to check.

  • selectors (string[], optional): DKIM selectors to probe.

  • response_format ('markdown' | 'json'): output format (default 'markdown').

Returns: { any_found, probed_selectors, selectors[{selector, found, record, key_type}], findings[] }.

Examples:

  • "Does acme.com publish a DKIM key for selector 'google'?" -> dkim_check(domain="acme.com", selectors=["google"])

  • "Find any DKIM keys for acme.com" -> dkim_check(domain="acme.com")

Inputs: domain (required), selectors, response_format. Returns: domain, findings, any_found, selectors, +1 more

dmarc_checkDMARC Record CheckA
Read-onlyIdempotent

Fetch and parse a domain's DMARC record (_dmarc.). Reports the policy (p=), subdomain policy (sp=), reporting addresses (rua/ruf), pct and alignment (aspf/adkim), and warns on monitor-only or partial deployments.

Args:

  • domain (string): the domain to check.

  • response_format ('markdown' | 'json'): output format (default 'markdown').

Returns: { found, record, policy, tags{}, findings[] }.

Example: "What is paypal.com's DMARC policy?" -> dmarc_check(domain="paypal.com").

Inputs: domain (required), response_format. Returns: tags, found, domain, policy, +2 more

dns_lookupDNS LookupA
Read-onlyIdempotent

Resolve all common DNS record types (A, AAAA, CNAME, MX, NS, TXT, SOA) for a domain in one call, using public resolvers (Cloudflare/Google/Quad9).

Args:

  • domain (string): the domain to query, e.g. "example.com".

  • response_format ('markdown' | 'json'): output format (default 'markdown').

Returns: a map of record type -> list of records. Each record has { type, host, value, priority? }.

Examples:

  • "What are the MX records for stripe.com?" -> dns_lookup(domain="stripe.com")

  • Use ssl_certificate for TLS details, whois_lookup for registration data.

Errors: returns an error if the domain is malformed or has no resolvable records.

Inputs: domain (required), response_format. Returns: domain, records

dns_propagationDNS Propagation CheckA
Read-onlyIdempotent

Compare a domain's DNS records across multiple public resolvers worldwide (Cloudflare, Google, Quad9, OpenDNS, AdGuard) to see whether a change has propagated.

Args:

  • domain (string): the domain to check.

  • type ('A'|'AAAA'|'CNAME'|'MX'|'NS'|'TXT'): record type (default 'A').

  • response_format ('markdown' | 'json'): output format (default 'markdown').

Returns: { type, consistent, resolvers[{name, server, values[], error}] }.

Example: "Has the A record for example.com propagated?" -> dns_propagation(domain="example.com").

Inputs: domain (required), type, response_format. Returns: type, domain, resolvers, consistent

dnssec_checkDNSSEC CheckA
Read-onlyIdempotent

Check whether a domain is protected by DNSSEC. Queries DS and DNSKEY records over DNS-over-HTTPS and reads the resolver's Authenticated Data (AD) flag to confirm the chain of trust validates.

Args:

  • domain (string): the domain to check.

  • response_format ('markdown' | 'json'): output format (default 'markdown').

Returns: { enabled, validated, ds_records, dnskey_records, findings[] }.

Example: "Is cloudflare.com DNSSEC-signed?" -> dnssec_check(domain="cloudflare.com").

Inputs: domain (required), response_format. Returns: domain, enabled, findings, validated, +2 more

email_auth_auditEmail Authentication AuditA
Read-onlyIdempotent

Headline tool. Audits a domain's email-authentication posture in one call — SPF, DKIM, DMARC and MX — then returns a 0–100 score, an A–F grade and a prioritised list of fixes. Use this first; reach for the per-record tools (spf_check, dmarc_check, dkim_check) only when you need the full detail of one mechanism.

Args:

  • domain (string): the domain to audit.

  • dkim_selectors (string[], optional): DKIM selectors to probe. If omitted, common provider selectors are tried (absence is then inconclusive).

  • response_format ('markdown' | 'json'): output format (default 'markdown').

Returns (JSON): { "domain": string, "grade": "A".."F", "score": number, // 0-100 "has_mx": boolean, "mx_hosts": string[], "spf": { found, record, all_qualifier, lookup_count, exceeds_lookup_limit, findings[] }, "dmarc":{ found, policy, tags, findings[] }, "dkim": { any_found, selectors[], findings[] }, "top_recommendations": string[] }

Examples:

  • "Is example.com protected against email spoofing?" -> email_auth_audit(domain="example.com")

  • "Audit acme.com, our DKIM selector is 'k1'" -> email_auth_audit(domain="acme.com", dkim_selectors=["k1"])

Errors: returns an error only if the domain is malformed; missing records are reported as findings, not errors.

Inputs: domain (required), dkim_selectors, response_format. Returns: spf, dkim, dmarc, grade, +5 more

http_security_headersHTTP Security HeadersA
Read-onlyIdempotent

Fetch a URL and grade its HTTP security headers (HSTS, Content-Security-Policy, X-Content-Type-Options, X-Frame-Options, Referrer-Policy, Permissions-Policy, COOP). Returns a 0–100 score, an A–F grade, and per-header notes.

Args:

  • url (string): URL or host to check (scheme defaults to https://).

  • response_format ('markdown' | 'json'): output format (default 'markdown').

Returns: { url, final_url, status, grade, score, checks[{header, present, value, note}], missing[] }.

Example: "Grade the security headers on https://news.ycombinator.com" -> http_security_headers(url="https://news.ycombinator.com"). Errors: returns an error if the URL is invalid or the host is unreachable.

Inputs: url (required), response_format. Returns: url, grade, score, checks, +3 more

ip_geolocationIP GeolocationA
Read-onlyIdempotent

Geolocate an IP address (country, region, city, coordinates, time zone) using the offline DB-IP Lite database, plus its reverse-DNS hostname. No external API.

Args:

  • ip (string): IPv4 or IPv6 address.

  • response_format ('markdown' | 'json'): output format (default 'markdown').

Returns: { ip, country_iso, country_name, region, city, latitude, longitude, time_zone, hostname }.

Example: "Where is 151.101.1.69 located?" -> ip_geolocation(ip="151.101.1.69"). Note: geolocation is approximate (city-level at best) and offline data may lag reality. The time zone is estimated from the coordinates. Data: IP Geolocation by DB-IP (https://db-ip.com), licensed CC BY 4.0 — credit it when showing these results.

Inputs: ip (required), response_format. Returns: ip, city, region, hostname, +5 more

mta_sts_checkMTA-STS CheckA
Read-onlyIdempotent

Check a domain's MTA-STS deployment: the _mta-sts TXT record AND the policy file at https://mta-sts./.well-known/mta-sts.txt. Reports the enforcement mode (enforce/testing/none) and the listed MX hosts. MTA-STS forces TLS for inbound SMTP and blocks downgrade attacks.

Args:

  • domain (string): the domain to check.

  • response_format ('markdown' | 'json'): output format (default 'markdown').

Returns: { dns_record_found, policy_found, mode, policy{}, findings[] }.

Example: "Does gmail.com enforce MTA-STS?" -> mta_sts_check(domain="gmail.com").

Inputs: domain (required), response_format. Returns: mode, domain, policy, findings, +2 more

mx_lookupMX LookupA
Read-onlyIdempotent

Look up a domain's mail servers (MX records) with priority and the IPs they resolve to.

Args:

  • domain (string): the domain to query.

  • response_format ('markdown' | 'json'): output format (default 'markdown').

Returns: array of { exchange, priority, ips[] }.

Example: "What are the mail servers for github.com?" -> mx_lookup(domain="github.com").

Inputs: domain (required), response_format. Returns: domain, records

reverse_dnsReverse DNS (PTR)A
Read-onlyIdempotent

Resolve the PTR (reverse DNS) records for an IP address — the hostname(s) the IP maps back to.

Args:

  • ip (string): IPv4 or IPv6 address.

  • response_format ('markdown' | 'json'): output format (default 'markdown').

Returns: { ip, hostnames: string[] }.

Example: "What hostname does 8.8.8.8 reverse to?" -> reverse_dns(ip="8.8.8.8"). Errors: returns an error if the IP is invalid or has no PTR record.

Inputs: ip (required), response_format. Returns: ip, hostnames

spf_checkSPF Record CheckA
Read-onlyIdempotent

Fetch and analyse a domain's SPF record. Detects: missing/multiple records, the trailing 'all' qualifier (+all/?all/~all/-all), and counts DNS-querying terms recursively against the RFC 7208 limit of 10.

Args:

  • domain (string): the domain to check.

  • response_format ('markdown' | 'json'): output format (default 'markdown').

Returns: { found, record, multiple_records, all_qualifier, lookup_count, exceeds_lookup_limit, findings[] }.

Example: "Does sendgrid.net's SPF exceed the 10-lookup limit?" -> spf_check(domain="sendgrid.net").

Inputs: domain (required), response_format. Returns: found, domain, record, findings, +4 more

ssl_certificateSSL/TLS Certificate InspectorA
Read-onlyIdempotent

Inspect the TLS certificate served by a host: issuer, subject, validity window, days-until-expiry, SANs, serial and SHA-256 fingerprint. Flags expired or soon-to-expire certificates.

Args:

  • domain (string): host to connect to.

  • port (number): TLS port (default 443).

  • response_format ('markdown' | 'json'): output format (default 'markdown').

Returns: certificate fields plus { days_until_expiry, expired, expires_soon, trusted, hostname_matches, authorization_error }. An untrusted certificate (self-signed, unknown root, wrong host) is still inspected and reported, never silently passed.

Example: "When does github.com's certificate expire?" -> ssl_certificate(domain="github.com"). Errors: returns an error if the host is unreachable or serves no certificate.

Inputs: domain (required), port, response_format. Returns: host, port, expired, trusted, +12 more

tls_rpt_checkTLS-RPT CheckA
Read-onlyIdempotent

Check a domain's TLS-RPT record (_smtp._tls. TXT). TLS-RPT lets you receive reports about TLS delivery failures to your domain.

Args:

  • domain (string): the domain to check.

  • response_format ('markdown' | 'json'): output format (default 'markdown').

Returns: { found, record, findings[] }.

Example: "Does microsoft.com publish TLS-RPT?" -> tls_rpt_check(domain="microsoft.com").

Inputs: domain (required), response_format. Returns: found, domain, record, findings

whois_lookupWHOIS LookupA
Read-onlyIdempotent

Look up domain registration data over the raw WHOIS protocol (port 43): registrar, creation/update/expiry dates, name servers and domain status. Resolves the correct WHOIS server via IANA and follows registrar referrals. No API key.

Args:

  • domain (string): the domain to look up.

  • response_format ('markdown' | 'json'): output format (default 'markdown'). JSON includes the raw WHOIS text.

Returns: { domain, registrar, created, updated, expires, name_servers[], status[], whois_server }.

Example: "Who is the registrar for openai.com and when does it expire?" -> whois_lookup(domain="openai.com"). Errors: returns an error if no WHOIS server answers (some ccTLDs restrict or rate-limit WHOIS).

Inputs: domain (required), response_format. Returns: raw, domain, status, created, +6 more

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A4.1/5.0

    Scored across 19 tools

    Disambiguation4/5

    Each tool targets a distinct security check (SPF, DMARC, DKIM, MTA-STS, TLS-RPT, BIMI, DNSSEC, CAA, etc.), and the aggregate email_auth_audit is explicitly positioned as the entry point versus the per-record detail tools. Minor overlap exists between dns_lookup and mx_lookup, but descriptions clarify their different purposes.

    Naming Consistency4/5

    Names are consistently snake_case and mostly follow a resource_check or resource_lookup pattern, which is predictable. A few deviations like email_auth_audit, reverse_dns, http_security_headers, and analyze_email_headers break the strict pattern but remain readable and recognizable.

    Tool Count3/5

    19 tools is on the heavy side and exceeds the comfortable 15-tool threshold, though the breadth is somewhat justified by covering email authentication, DNS, TLS, web headers, WHOIS, and blacklists. It is not excessive enough to feel chaotic, but it is borderline for an MCP server.

    Completeness5/5

    For a read-only domain security auditor, the surface is remarkably complete: email authentication, DNSSEC/CAA, TLS certificates, HTTP security headers, WHOIS, blacklists, and email header forensics are all covered. The aggregate audit plus per-record detail tools form a coherent workflow with no major dead ends.

    Maintenance

    ActivityMaintained
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      C
      maintenance
      Enables AI agents to perform passive security scans on domains, checking email spoofing (DMARC/SPF/DKIM), TLS weaknesses, security headers, exposed files, and subdomain-takeover risk without needing an API key.
      7
      77 npm
      MIT
    • A
      license
      Not graded
      quality
      C
      maintenance
      Enables AI assistants to check a domain's email authentication and health across SPF, DKIM, DMARC, BIMI, MX, MTA-STS, and TLS-RPT, returning a score and recommended fixes.
      MIT
    • A
      license
      A
      quality
      C
      maintenance
      Enables AI agents to inspect any public domain’s web technology stack, email deliverability and DNS health (MX, SPF, DKIM, DMARC, MTA-STS, TLS-RPT, BIMI), and HTTPS security posture with typed JSON scores and remediation-ready findings, plus history, bulk checks, monitoring alerts, and reverse technology lookups.
      12
      61 npm
      MIT
    • A
      license
      Not graded
      quality
      B
      maintenance
      DNS and email security checks for AI agents: SPF, DKIM, DMARC, MTA-STS, DNSSEC, TLS and more, with a fix for every finding. Pay per call in USDC on Base via x402, with dry run by default and a per-session spending cap.
      MIT