agent-press-wire-mcp 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Dylan Caponi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,129 @@
+# Agent Press Wire MCP server
+
+An MCP server that lets AI agents (Claude Desktop, Claude Code, Cursor, any MCP client) announce product launches and distribute press releases through [Agent Press Wire](https://agent-press-wire.dylan-caponi.workers.dev). Each call is paid in USDC on Base over [x402](https://x402.org), from **your own wallet**. No account, no API key.
+
+## Tools
+
+| Tool | Price | What it does |
+| --- | --- | --- |
+| `announce_launch_newsroom` | $1 USDC | Drafts a 350-450 word AP-style press release from your product URL and publishes it on a public, search-indexed newsroom page. About 20 seconds. |
+| `distribute_press_release` | `tier: "wire"` $99 USDC, `tier: "premium"` $299 USDC | Drafts a 450-600 word release and distributes it over a newswire to 500+ news sites plus 100+ TV and radio network sites. Premium adds AP News, USA Today, Barchart and StreetInsider. Requires `city`, `country`, `contact_email`. Returns an `order_id`. |
+| `get_release_status` | Free | Status and live coverage links for a wire order. |
+
+The service only charges when the job succeeds. Failed drafts, rejected topics and wire rejections are not charged.
+
+## Safety: quote mode by default
+
+Paid tools **charge real USDC**. Settings that control spending:
+
+- `X402_PRIVATE_KEY`: private key of your own Base wallet holding USDC. Without it the server only quotes.
+- `MAX_SPEND_USD`: the most the server may pay for a single call. Default `0`, which means quote only: every paid tool returns the x402 price terms and never pays.
+- `MAX_TOTAL_SPEND_USD`: lifetime cap across all calls and restarts. Defaults to `MAX_SPEND_USD`, so out of the box you get at most one paid call until you raise it. Spend is tracked in a ledger at `~/.agent-press-wire/spend.json` (override the directory with `AGENT_PRESS_WIRE_HOME`). Every signed payment authorization is counted, whatever the HTTP outcome, because the server could still settle it until it expires. If a call failed and your wallet shows no transfer for its nonce after `valid_before`, you can delete that entry from the ledger.
+
+Paying takes two calls. The first call (without `confirm_token`, or with `quote_only: true`) returns the price and a `confirm_token`. The agent shows the user the exact price, and after the user approves it calls again with the **same parameters** and that `confirm_token`. Tokens are single use, expire after 10 minutes, and are bound to the endpoint, a hash of the request parameters and the price.
+
+A payment only happens when all of these hold:
+
+- the key is set, the price is at or below `MAX_SPEND_USD`, and the lifetime total stays at or below `MAX_TOTAL_SPEND_USD`;
+- a valid `confirm_token` was passed and `quote_only` is not true;
+- the server's x402 terms match values pinned in this package: pay to `0xF7887C1fAf0DbAedc80C78F9D396D594B69eba95`, exactly $1 for `/v1/press-release`, $99 for `/v1/wire-release`, $299 for `/v1/wire-release/premium`, USDC on Base mainnet, scheme `exact` with an EIP-3009 transfer authorization, and `maxTimeoutSeconds` of 600 or less. Any mismatch is refused, so a compromised server or a wrong `PRESS_API_URL` cannot redirect funds or raise the price.
+
+The per-call cap is enforced twice: by this server before signing, and by the x402 client's own spend controls.
+
+If a paid call fails after the authorization was signed, the result says the payment was **not settled per the server** and includes the authorization `nonce`, `valid_before` and payer address. Check your wallet before retrying.
+
+Examples: `MAX_SPEND_USD=1 MAX_TOTAL_SPEND_USD=5` allows up to five $1 newsroom releases and only quotes the wire tiers. `MAX_SPEND_USD=99 MAX_TOTAL_SPEND_USD=99` allows one standard wire release. Use a dedicated wallet funded with only what you intend to spend.
+
+## Install
+
+Requires Node 20+.
+
+### Claude Code
+
+```bash
+claude mcp add agent-press-wire \
+  -e X402_PRIVATE_KEY=0xYOUR_KEY -e MAX_SPEND_USD=1 -e MAX_TOTAL_SPEND_USD=5 \
+  -- npx -y agent-press-wire-mcp
+```
+
+Quote only (no wallet): `claude mcp add agent-press-wire -- npx -y agent-press-wire-mcp`
+
+### Claude Desktop
+
+Edit `claude_desktop_config.json` (macOS: `~/Library/Application Support/Claude/claude_desktop_config.json`, Windows: `%APPDATA%\Claude\claude_desktop_config.json`):
+
+```json
+{
+  "mcpServers": {
+    "agent-press-wire": {
+      "command": "npx",
+      "args": ["-y", "agent-press-wire-mcp"],
+      "env": {
+        "X402_PRIVATE_KEY": "0xYOUR_KEY",
+        "MAX_SPEND_USD": "1",
+        "MAX_TOTAL_SPEND_USD": "5"
+      }
+    }
+  }
+}
+```
+
+### Cursor
+
+Add to `~/.cursor/mcp.json` (global) or `.cursor/mcp.json` (project):
+
+```json
+{
+  "mcpServers": {
+    "agent-press-wire": {
+      "command": "npx",
+      "args": ["-y", "agent-press-wire-mcp"],
+      "env": {
+        "X402_PRIVATE_KEY": "0xYOUR_KEY",
+        "MAX_SPEND_USD": "1",
+        "MAX_TOTAL_SPEND_USD": "5"
+      }
+    }
+  }
+}
+```
+
+Other clients: run `npx -y agent-press-wire-mcp` as a stdio server with the same environment variables.
+
+## Example prompts
+
+- "Announce my launch: https://example.com, we just shipped v2 with offline mode."
+- "Write and distribute a press release for https://example.com. We're in Austin, United States, press@example.com."
+- "How much would it cost to get press coverage for my product?" (the agent calls with `quote_only: true`)
+- After the user approves a quoted price, the agent repeats the call with the returned `confirm_token`.
+- "Check the status of press release w_3f9d0a1b2c."
+
+## Quote response
+
+```json
+{
+  "mode": "quote",
+  "paid": false,
+  "reason": "no confirm_token: this was a quote",
+  "quote": { "price_usd": 99, "asset": "USDC", "network": "Base mainnet (eip155:8453)", "pay_to": "0xF7887C1fAf0DbAedc80C78F9D396D594B69eba95" },
+  "spend": { "spent_total_usd": 0, "max_total_spend_usd": 99, "max_spend_usd": 99 },
+  "confirm_token": "ct1.1791069332201.6cba...d563",
+  "confirm_token_expires_in_seconds": 600
+}
+```
+
+## Development
+
+```bash
+npm install
+npm run build
+npm test             # offline guard-rail tests against a localhost mock x402 server; never pays
+npm run test:quote   # quote-mode smoke test against production; never pays
+npx @modelcontextprotocol/inspector node dist/index.js
+```
+
+`PRESS_API_URL` overrides the API base URL for testing.
+
+## License
+
+MIT

package/dist/guard.js

@@ -0,0 +1,141 @@
+// Payment guard rails for the Agent Press Wire MCP server (audit item M2).
+// Pure, testable pieces: pinned payment terms, confirm tokens, and the persisted spend ledger.
+import { createHash, createHmac, randomBytes, timingSafeEqual } from "node:crypto";
+import { mkdirSync, readFileSync, renameSync, writeFileSync, existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+export const NETWORK = "eip155:8453"; // Base mainnet
+export const USDC_BASE = "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913";
+export const USDC_DECIMALS = 6;
+/** Agent Press Wire's receiving wallet. Hard-coded so a compromised server or PRESS_API_URL cannot redirect funds. */
+export const PAY_TO = "0xF7887C1fAf0DbAedc80C78F9D396D594B69eba95";
+/** Expected price per endpoint, in atomic USDC (6 decimals). Any other amount is refused. */
+export const EXPECTED_ATOMIC = Object.freeze({
+    "/v1/press-release": "1000000",
+    "/v1/wire-release": "99000000",
+    "/v1/wire-release/premium": "299000000",
+});
+export const MAX_TIMEOUT_SECONDS = 600;
+export const CONFIRM_TTL_MS = 10 * 60 * 1000;
+export const usdToAtomic = (usd) => BigInt(Math.round(usd * 10 ** USDC_DECIMALS));
+export const atomicToUsd = (atomic) => Number(BigInt(atomic)) / 10 ** USDC_DECIMALS;
+/** Returns null when the 402 terms match what we expect for this endpoint, else a human-readable reason. */
+export function checkPinnedTerms(path, req) {
+    const expected = EXPECTED_ATOMIC[path];
+    if (!expected)
+        return `no pinned price for endpoint ${path}`;
+    if (req.scheme !== "exact")
+        return `unexpected x402 scheme ${JSON.stringify(req.scheme)} (expected "exact")`;
+    if (req.network !== NETWORK)
+        return `unexpected network ${JSON.stringify(req.network)} (expected ${NETWORK})`;
+    if (String(req.asset ?? "").toLowerCase() !== USDC_BASE)
+        return `unexpected asset ${JSON.stringify(req.asset)} (expected USDC on Base)`;
+    const method = req.extra?.assetTransferMethod;
+    if (method !== undefined && method !== "eip3009")
+        return `unexpected assetTransferMethod ${JSON.stringify(method)} (only eip3009 is allowed)`;
+    if (String(req.payTo ?? "").toLowerCase() !== PAY_TO.toLowerCase())
+        return `payTo ${JSON.stringify(req.payTo)} does not match the pinned Agent Press Wire wallet ${PAY_TO}`;
+    if (String(req.amount) !== expected)
+        return `amount ${JSON.stringify(req.amount)} does not match the pinned price ${expected} atomic USDC ($${atomicToUsd(expected)}) for ${path}`;
+    const t = req.maxTimeoutSeconds;
+    if (typeof t !== "number" || !Number.isInteger(t) || t <= 0 || t > MAX_TIMEOUT_SECONDS)
+        return `maxTimeoutSeconds ${JSON.stringify(t)} is outside 1..${MAX_TIMEOUT_SECONDS}`;
+    return null;
+}
+// ---------- confirm tokens ----------
+/** Stable JSON: sorted keys, undefined dropped. */
+export function canonicalJson(v) {
+    if (v === null || typeof v !== "object")
+        return JSON.stringify(v);
+    if (Array.isArray(v))
+        return `[${v.map(canonicalJson).join(",")}]`;
+    const o = v;
+    return `{${Object.keys(o)
+        .filter((k) => o[k] !== undefined)
+        .sort()
+        .map((k) => `${JSON.stringify(k)}:${canonicalJson(o[k])}`)
+        .join(",")}}`;
+}
+export const paramsHash = (path, body) => createHash("sha256").update(`${path}\n${canonicalJson(body)}`).digest("hex");
+/**
+ * Issues and verifies single-use confirm tokens. A token is bound to the endpoint, a hash of the
+ * request params and the quoted amount, signed with a per-process random secret, and expires.
+ */
+export class ConfirmTokens {
+    ttlMs;
+    secret;
+    used = new Map();
+    constructor(ttlMs = CONFIRM_TTL_MS, secret) {
+        this.ttlMs = ttlMs;
+        this.secret = secret ?? randomBytes(32);
+    }
+    mac(exp, path, body, amount) {
+        return createHmac("sha256", this.secret).update(`${exp}|${path}|${paramsHash(path, body)}|${amount}`).digest("hex");
+    }
+    issue(path, body, amount, now = Date.now()) {
+        const exp = now + this.ttlMs;
+        return `ct1.${exp}.${this.mac(exp, path, body, amount)}`;
+    }
+    /** Returns null if valid (and marks the token used), else the reason it was rejected. */
+    consume(token, path, body, amount, now = Date.now()) {
+        for (const [t, exp] of this.used)
+            if (exp < now)
+                this.used.delete(t);
+        const m = /^ct1\.(\d{13,})\.([0-9a-f]{64})$/.exec(token.trim());
+        if (!m)
+            return "confirm_token is malformed";
+        const exp = Number(m[1]);
+        const want = Buffer.from(this.mac(exp, path, body, amount), "hex");
+        const got = Buffer.from(m[2], "hex");
+        if (want.length !== got.length || !timingSafeEqual(want, got))
+            return "confirm_token does not match this endpoint, these exact parameters and this price (or was issued by another server process)";
+        if (exp < now)
+            return "confirm_token has expired";
+        if (this.used.has(m[2]))
+            return "confirm_token was already used";
+        this.used.set(m[2], exp);
+        return null;
+    }
+}
+export const ledgerDir = () => process.env.AGENT_PRESS_WIRE_HOME || join(homedir(), ".agent-press-wire");
+export const ledgerPath = (dir = ledgerDir()) => join(dir, "spend.json");
+/** Loads the ledger. Missing file means empty. A corrupt file throws, so the caller fails closed. */
+export function loadLedger(dir = ledgerDir()) {
+    const p = ledgerPath(dir);
+    if (!existsSync(p))
+        return { version: 1, entries: [] };
+    const parsed = JSON.parse(readFileSync(p, "utf8"));
+    if (parsed?.version !== 1 || !Array.isArray(parsed.entries))
+        throw new Error(`spend ledger ${p} is not a valid version 1 ledger`);
+    for (const e of parsed.entries)
+        BigInt(e.amount_atomic); // throws on garbage
+    return parsed;
+}
+export function saveLedger(ledger, dir = ledgerDir()) {
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    const p = ledgerPath(dir);
+    const tmp = `${p}.${process.pid}.tmp`;
+    writeFileSync(tmp, JSON.stringify(ledger, null, 2) + "\n", { mode: 0o600 });
+    renameSync(tmp, p);
+}
+/**
+ * Every signed authorization counts toward the total, whatever the HTTP outcome, because the
+ * server holds a settleable authorization until valid_before. Remove an entry by hand only after
+ * confirming on-chain that it never settled.
+ */
+export const totalSpentAtomic = (ledger) => ledger.entries.reduce((s, e) => s + BigInt(e.amount_atomic), 0n);
+/** Returns null if paying `amount` keeps the lifetime total within the cap, else the reason. */
+export function checkTotalCap(ledger, amountAtomic, maxTotalUsd) {
+    const spent = totalSpentAtomic(ledger);
+    const cap = usdToAtomic(maxTotalUsd);
+    if (spent + amountAtomic > cap)
+        return `paying $${atomicToUsd(amountAtomic)} would bring total spend to $${atomicToUsd(spent + amountAtomic)}, over MAX_TOTAL_SPEND_USD=${maxTotalUsd} (already spent $${atomicToUsd(spent)} per ${ledgerPath()})`;
+    return null;
+}
+/** Serializes ledger check + write within this process so concurrent calls cannot both pass the cap. */
+let chain = Promise.resolve();
+export function withLedgerLock(fn) {
+    const run = chain.then(fn, fn);
+    chain = run.catch(() => undefined);
+    return run;
+}

package/dist/index.js

@@ -0,0 +1,339 @@
+#!/usr/bin/env node
+// Agent Press Wire MCP server (stdio).
+// Lets AI agents announce launches and distribute press releases via
+// https://agent-press-wire.dylan-caponi.workers.dev, paying per call in USDC on Base over x402.
+//
+// Safety (all must hold before anything is signed):
+//   X402_PRIVATE_KEY set, quoted price <= MAX_SPEND_USD (default 0 = quote only),
+//   lifetime total <= MAX_TOTAL_SPEND_USD (persisted ledger), 402 terms match the pinned
+//   payTo / price / asset / network, maxTimeoutSeconds <= 600, and a valid confirm_token
+//   from a prior quote for the same endpoint and parameters.
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { x402Client, x402HTTPClient } from "@x402/fetch";
+import { ExactEvmScheme } from "@x402/evm/exact/client";
+import { privateKeyToAccount } from "viem/accounts";
+import { z } from "zod";
+import { NETWORK, USDC_BASE, PAY_TO, CONFIRM_TTL_MS, ConfirmTokens, atomicToUsd, checkPinnedTerms, checkTotalCap, ledgerPath, loadLedger, saveLedger, totalSpentAtomic, usdToAtomic, withLedgerLock, } from "./guard.js";
+const VERSION = "0.1.0";
+const BASE_URL = (process.env.PRESS_API_URL || "https://agent-press-wire.dylan-caponi.workers.dev").replace(/\/+$/, "");
+const TIMEOUT_MS = 180_000;
+function envUsd(name, fallback) {
+    const raw = process.env[name];
+    if (raw === undefined || raw.trim() === "")
+        return fallback;
+    const v = Number(raw);
+    return Number.isFinite(v) && v > 0 ? v : 0;
+}
+const maxSpendUsd = () => envUsd("MAX_SPEND_USD", 0);
+/** Lifetime cap across all calls and restarts. Defaults to MAX_SPEND_USD (one paid call's worth). */
+const maxTotalSpendUsd = () => envUsd("MAX_TOTAL_SPEND_USD", maxSpendUsd());
+function walletKey() {
+    const raw = (process.env.X402_PRIVATE_KEY || "").trim();
+    if (!raw)
+        return null;
+    const k = raw.startsWith("0x") ? raw : `0x${raw}`;
+    if (!/^0x[0-9a-fA-F]{64}$/.test(k))
+        throw new Error("X402_PRIVATE_KEY must be a 32-byte hex private key");
+    return k;
+}
+const ok = (obj) => ({ content: [{ type: "text", text: JSON.stringify(obj, null, 2) }] });
+const fail = (obj) => ({ ...ok(obj), isError: true });
+async function readBody(res) {
+    const text = await res.text();
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text.slice(0, 2000);
+    }
+}
+function pickUsdcOnBase(pr) {
+    return pr.accepts.find((r) => r.network === NETWORK && String(r.asset).toLowerCase() === USDC_BASE);
+}
+const tokens = new ConfirmTokens();
+function updateLedgerEntry(nonce, ts, patch) {
+    try {
+        const l = loadLedger();
+        const e = l.entries.find((x) => x.ts === ts && x.nonce === nonce);
+        if (e)
+            Object.assign(e, patch);
+        saveLedger(l);
+    }
+    catch (err) {
+        console.error(`could not update spend ledger: ${err.message}`);
+    }
+}
+/**
+ * POST to a paid endpoint. First call is always unpaid to read the 402 terms, which must match the
+ * pinned payTo and price. Without a valid confirm_token (or with quote_only) it returns a quote and
+ * a fresh confirm_token. With one, it pays only if every rail allows it.
+ */
+async function paidPost(path, body, quoteOnly, confirmToken) {
+    const url = `${BASE_URL}${path}`;
+    const init = {
+        method: "POST",
+        headers: { "content-type": "application/json", "user-agent": `agent-press-wire-mcp/${VERSION}` },
+        body: JSON.stringify(body),
+    };
+    let first;
+    try {
+        first = await fetch(url, { ...init, signal: AbortSignal.timeout(TIMEOUT_MS) });
+    }
+    catch (e) {
+        return fail({ error: `network error calling ${url}: ${e.message}` });
+    }
+    if (first.status !== 402) {
+        // Should not happen for a paid route; surface whatever the server said.
+        return first.ok ? ok(await readBody(first)) : fail({ http_status: first.status, response: await readBody(first) });
+    }
+    // Parse x402 payment terms. Use a scheme-less client purely for decoding.
+    const decoder = new x402HTTPClient(new x402Client());
+    let terms;
+    try {
+        terms = decoder.getPaymentRequiredResponse((n) => first.headers.get(n), await readBody(first));
+    }
+    catch (e) {
+        return fail({ error: `could not parse x402 payment terms: ${e.message}` });
+    }
+    const req = pickUsdcOnBase(terms);
+    if (!req)
+        return fail({ error: "server did not offer USDC on Base; refusing to pay", accepts: terms.accepts });
+    const mismatch = checkPinnedTerms(path, req);
+    if (mismatch)
+        return fail({
+            error: `refusing to pay: the server's x402 terms do not match the pinned Agent Press Wire terms. ${mismatch}`,
+            charged: false,
+            offered: req,
+        });
+    const priceAtomic = BigInt(req.amount);
+    const priceUsd = atomicToUsd(priceAtomic);
+    const cap = maxSpendUsd();
+    const totalCap = maxTotalSpendUsd();
+    const quote = {
+        endpoint: `POST ${url}`,
+        price_usd: priceUsd,
+        price_usdc_atomic: req.amount,
+        asset: "USDC",
+        network: "Base mainnet (eip155:8453)",
+        pay_to: req.payTo,
+        description: terms.resource?.description,
+    };
+    let key;
+    try {
+        key = walletKey();
+    }
+    catch (e) {
+        return fail({ error: e.message, quote });
+    }
+    let spentAtomic;
+    try {
+        spentAtomic = totalSpentAtomic(loadLedger());
+    }
+    catch (e) {
+        return fail({ error: `refusing to pay: cannot read spend ledger ${ledgerPath()}: ${e.message}`, quote });
+    }
+    const totalReason = spentAtomic + priceAtomic > usdToAtomic(totalCap)
+        ? `total spend would be $${atomicToUsd(spentAtomic + priceAtomic)}, over MAX_TOTAL_SPEND_USD=${totalCap} (already spent $${atomicToUsd(spentAtomic)} per ${ledgerPath()})`
+        : null;
+    const blocker = !key
+        ? "X402_PRIVATE_KEY is not set"
+        : priceUsd > cap
+            ? `price $${priceUsd} exceeds MAX_SPEND_USD=${cap} (set MAX_SPEND_USD >= ${priceUsd} to allow this charge)`
+            : totalReason;
+    if (quoteOnly || !confirmToken || blocker) {
+        const reason = quoteOnly ? "quote_only=true" : blocker ?? "no confirm_token: this was a quote";
+        return ok({
+            mode: "quote",
+            paid: false,
+            charged: false,
+            reason,
+            quote,
+            spend: { spent_total_usd: atomicToUsd(spentAtomic), max_total_spend_usd: totalCap, max_spend_usd: cap },
+            confirm_token: tokens.issue(path, body, req.amount),
+            confirm_token_expires_in_seconds: CONFIRM_TTL_MS / 1000,
+            next_step: blocker
+                ? `Paying is not possible right now: ${blocker}. Show the user this price; the user must change the MCP server settings to allow it.`
+                : "Show the user this exact price and get explicit approval. Then call this tool again with the SAME parameters, quote_only=false and this confirm_token (single use, expires in 10 minutes).",
+        });
+    }
+    const tokenError = tokens.consume(confirmToken, path, body, req.amount);
+    if (tokenError)
+        return fail({
+            error: `refusing to pay: ${tokenError}. Call again with quote_only=true to get a fresh quote and confirm_token, confirm the price with the user, then retry with identical parameters.`,
+            charged: false,
+            quote,
+        });
+    // Pay. Second guard: x402 client-side spend control capped at MAX_SPEND_USD.
+    const account = privateKeyToAccount(key);
+    const client = new x402Client()
+        .register(NETWORK, new ExactEvmScheme(account))
+        .registerPolicy((_v, reqs) => reqs.filter((r) => checkPinnedTerms(path, r) === null && atomicToUsd(r.amount) <= cap))
+        .setSpendControls({ maxAmountPerPayment: `$${cap}` });
+    const http = new x402HTTPClient(client);
+    // Total cap check, signing and the ledger write happen under one lock so concurrent calls cannot both pass.
+    const signed = await withLedgerLock(async () => {
+        let ledger;
+        try {
+            ledger = loadLedger();
+        }
+        catch (e) {
+            return { error: `refusing to pay: cannot read spend ledger ${ledgerPath()}: ${e.message}` };
+        }
+        const over = checkTotalCap(ledger, priceAtomic, totalCap);
+        if (over)
+            return { error: `refusing to pay: ${over}` };
+        let payload;
+        try {
+            payload = await http.createPaymentPayload({ ...terms, accepts: [req] });
+        }
+        catch (e) {
+            return { error: `could not create payment: ${e.message}` };
+        }
+        const auth = payload.payload?.authorization;
+        if (!auth || String(auth.to).toLowerCase() !== PAY_TO.toLowerCase() || String(auth.value) !== req.amount)
+            return { error: "refusing to send: signed authorization does not match the pinned payTo and price" };
+        const entry = {
+            ts: new Date().toISOString(),
+            endpoint: path,
+            amount_atomic: req.amount,
+            pay_to: req.payTo,
+            nonce: auth.nonce ?? null,
+            valid_before: auth.validBefore ?? null,
+            status: "signed",
+        };
+        ledger.entries.push(entry);
+        try {
+            saveLedger(ledger);
+        }
+        catch (e) {
+            return { error: `refusing to send payment: cannot write spend ledger ${ledgerPath()}: ${e.message}` };
+        }
+        return { headers: http.encodePaymentSignatureHeader(payload), entry };
+    });
+    if ("error" in signed)
+        return fail({ error: signed.error, charged: false, quote });
+    const { headers: paymentHeaders, entry } = signed;
+    const payment = { nonce: entry.nonce, valid_before_unix: entry.valid_before, payer: account.address, pay_to: entry.pay_to };
+    let res;
+    try {
+        res = await fetch(url, {
+            ...init,
+            headers: { ...init.headers, ...paymentHeaders },
+            signal: AbortSignal.timeout(TIMEOUT_MS),
+        });
+    }
+    catch (e) {
+        updateLedgerEntry(entry.nonce, entry.ts, { status: "unknown_network_error" });
+        return fail({
+            error: `network error after sending a signed payment authorization: ${e.message}. Settlement status is unknown. Check your wallet for a USDC transfer with this authorization nonce before retrying.`,
+            settled: "unknown",
+            payment,
+            quote,
+        });
+    }
+    let settlement = null;
+    try {
+        settlement = http.getPaymentSettleResponse((n) => res.headers.get(n));
+    }
+    catch {
+        /* no settlement header */
+    }
+    const result = await readBody(res);
+    if (!res.ok) {
+        updateLedgerEntry(entry.nonce, entry.ts, { status: "not_settled_per_server", http_status: res.status });
+        return fail({
+            http_status: res.status,
+            settled: "not settled per server",
+            note: `The server reported failure and says it did not settle the payment, but it holds a signed authorization until valid_before. Check your wallet for a USDC transfer with nonce ${entry.nonce} before retrying. This authorization still counts toward MAX_TOTAL_SPEND_USD in ${ledgerPath()}.`,
+            payment,
+            response: result,
+            quote,
+        });
+    }
+    updateLedgerEntry(entry.nonce, entry.ts, { status: "settled", http_status: res.status });
+    return ok({ mode: "paid", paid: true, price_usd: priceUsd, payment, settlement, result });
+}
+const server = new McpServer({ name: "agent-press-wire", version: VERSION });
+const PAY_NOTE = "Charges REAL USDC on Base mainnet from the user's own wallet (X402_PRIVATE_KEY) via x402. Two steps: call first WITHOUT confirm_token (or with quote_only=true) to get the price and a confirm_token; show the user the exact price and get explicit approval; then call again with identical parameters and that confirm_token (single use, expires in 10 minutes). " +
+    "It only pays if the price is <= MAX_SPEND_USD, the lifetime total stays <= MAX_TOTAL_SPEND_USD, and the server's payment terms match the pinned Agent Press Wire wallet and price; otherwise it returns the quote without paying. The service only settles payment if the job succeeds.";
+const announcement = z
+    .string()
+    .max(500)
+    .optional()
+    .describe("What is being announced (launch, new version, feature, funding, milestone). Strongly recommended: without it only news visible on the page is written about, and the call fails uncharged if there is none.");
+const quoteOnly = z
+    .boolean()
+    .optional()
+    .default(false)
+    .describe("If true, never pay: just return the x402 price quote and a confirm_token. Use this first to show the user the price.");
+const confirmToken = z
+    .string()
+    .max(200)
+    .optional()
+    .describe("confirm_token from a previous quote of this tool with the exact same parameters, passed only after the user approved the quoted price. Without it the call only quotes.");
+server.registerTool("announce_launch_newsroom", {
+    title: "Announce a launch (press release on newsroom page, $1)",
+    description: `Announce a product launch, release, or update with a press release. PRICE: $1 USDC per call. Use when the user says things like "announce my launch", "write a press release", "publish a press release for my product", "announce our new version". ` +
+        "Given a product URL, Agent Press Wire drafts a factual 350-450 word AP-style press release from the page and publishes it on a public, search-indexed newsroom page (IndexNow ping to Bing/Yandex). Returns the headline, newsroom URL, and the release in markdown. About 20 seconds. " +
+        "For distribution to real news sites, use distribute_press_release instead. " +
+        PAY_NOTE,
+    inputSchema: {
+        product_url: z.string().url().describe("Public URL of the product, launch page, or repo being announced."),
+        announcement,
+        company: z.string().max(100).optional().describe("Optional company or project name."),
+        contact: z.string().max(200).optional().describe("Optional media contact line (name, email or URL) printed at the end."),
+        quote_only: quoteOnly,
+        confirm_token: confirmToken,
+    },
+    annotations: { title: "Announce launch ($1)", readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
+}, async ({ product_url, announcement, company, contact, quote_only, confirm_token }) => paidPost("/v1/press-release", { product_url, announcement, company, contact }, quote_only, confirm_token));
+server.registerTool("distribute_press_release", {
+    title: "Write and distribute a press release over a newswire ($99 / $299)",
+    description: `Write a press release and distribute it over a newswire to get press coverage. PRICE: tier "wire" = $99 USDC (500+ news sites plus 100+ TV and radio network sites); tier "premium" = $299 USDC (everything in wire plus AP News, USA Today, Barchart, StreetInsider). ` +
+        `Use when the user says things like "get press coverage", "write and distribute a press release", "send a press release to news sites", "put out a press release on the wire", "PR distribution". ` +
+        "Drafts a 450-600 word AP-style release from the product URL; it goes through editorial review and is distributed, usually same day on weekdays. Returns an order_id; poll get_release_status for live links. Not accepted: crypto token sales, gambling, adult, health/cure claims, cannabis. " +
+        PAY_NOTE,
+    inputSchema: {
+        tier: z.enum(["wire", "premium"]).describe('"wire" = $99 (500+ news sites); "premium" = $299 (adds AP News, USA Today, Barchart, StreetInsider).'),
+        product_url: z.string().url().describe("Public URL of the product, launch page, or repo being announced."),
+        city: z.string().min(1).max(80).describe("City of the announcing company (newswire dateline)."),
+        country: z.string().min(1).max(80).describe("Country name, e.g. 'United States'."),
+        contact_email: z.string().email().describe("Media contact email printed on the release (required by newswires)."),
+        announcement,
+        company: z.string().max(100).optional().describe("Optional company or project name."),
+        quote_only: quoteOnly,
+        confirm_token: confirmToken,
+    },
+    annotations: { title: "Distribute press release ($99/$299)", readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
+}, async ({ tier, product_url, city, country, contact_email, announcement, company, quote_only, confirm_token }) => paidPost(tier === "premium" ? "/v1/wire-release/premium" : "/v1/wire-release", { product_url, city, country, contact_email, announcement, company }, quote_only, confirm_token));
+server.registerTool("get_release_status", {
+    title: "Get press release distribution status (free)",
+    description: "FREE. Check the status of a newswire press release order from distribute_press_release (order id like w_ab12cd34ef) and get live links to the published coverage once distributed.",
+    inputSchema: {
+        order_id: z.string().describe("The order_id returned by distribute_press_release, e.g. w_3f9d0a1b2c."),
+    },
+    annotations: { title: "Release status (free)", readOnlyHint: true, openWorldHint: true },
+}, async ({ order_id }) => {
+    const id = order_id.trim();
+    if (!/^w_[0-9a-f]+$/.test(id))
+        return fail({ error: "order_id must look like w_<hex>, as returned by distribute_press_release" });
+    let res;
+    try {
+        res = await fetch(`${BASE_URL}/v1/wire-release/${id}`, {
+            headers: { "user-agent": `agent-press-wire-mcp/${VERSION}` },
+            signal: AbortSignal.timeout(30_000),
+        });
+    }
+    catch (e) {
+        return fail({ error: `network error: ${e.message}` });
+    }
+    const body = await readBody(res);
+    if (res.status === 404)
+        return fail({ error: `no wire order found with id ${id}`, http_status: 404 });
+    if (!res.ok)
+        return fail({ http_status: res.status, response: body });
+    return ok(body);
+});
+await server.connect(new StdioServerTransport());
+console.error(`agent-press-wire MCP ${VERSION} ready (${BASE_URL}, MAX_SPEND_USD=${maxSpendUsd()}, MAX_TOTAL_SPEND_USD=${maxTotalSpendUsd()}, ledger ${ledgerPath()}, wallet ${process.env.X402_PRIVATE_KEY ? "set" : "not set"})`);

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "agent-press-wire-mcp",
+  "version": "0.1.0",
+  "description": "MCP server for Agent Press Wire: AI agents announce launches and distribute press releases to 500+ news sites, paid per call in USDC over x402.",
+  "mcpName": "io.github.dylancaponi/agent-press-wire",
+  "type": "module",
+  "bin": { "agent-press-wire-mcp": "dist/index.js" },
+  "main": "dist/index.js",
+  "files": ["dist", "README.md", "server.json", "LICENSE"],
+  "scripts": {
+    "build": "tsc && chmod +x dist/index.js",
+    "start": "node dist/index.js",
+    "test": "npm run build && node --test test/hardening-test.mjs",
+    "test:quote": "node test/quote-test.mjs",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": ["mcp", "model-context-protocol", "press-release", "pr", "launch", "newswire", "x402", "usdc", "base", "ai-agents"],
+  "homepage": "https://agent-press-wire.dylan-caponi.workers.dev",
+  "author": "Dylan Caponi",
+  "license": "MIT",
+  "engines": { "node": ">=20" },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "1.32.0",
+    "@x402/core": "2.28.0",
+    "@x402/evm": "2.28.0",
+    "@x402/fetch": "2.28.0",
+    "viem": "2.57.2",
+    "zod": "4.6.5"
+  },
+  "devDependencies": {
+    "@types/node": "26.6.4",
+    "typescript": "7.0.2"
+  }
+}

package/server.json

@@ -0,0 +1,54 @@
+{
+  "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
+  "name": "io.github.dylancaponi/agent-press-wire",
+  "title": "Agent Press Wire",
+  "description": "Announce launches and distribute press releases to 500+ news sites. Pay per call in USDC (x402).",
+  "websiteUrl": "https://agent-press-wire.dylan-caponi.workers.dev",
+  "version": "0.1.0",
+  "packages": [
+    {
+      "registryType": "npm",
+      "identifier": "agent-press-wire-mcp",
+      "version": "0.1.0",
+      "transport": { "type": "stdio" },
+      "environmentVariables": [
+        {
+          "name": "X402_PRIVATE_KEY",
+          "description": "Private key of YOUR OWN Base wallet holding USDC, used to pay per call via x402. Omit for quote-only mode.",
+          "isRequired": false,
+          "isSecret": true,
+          "format": "string"
+        },
+        {
+          "name": "MAX_SPEND_USD",
+          "description": "Max USD the server may pay for a single call. 0 (default) = quote only, never pays. Prices: $1 newsroom, $99 wire, $299 premium wire.",
+          "isRequired": false,
+          "isSecret": false,
+          "format": "number",
+          "default": "0"
+        },
+        {
+          "name": "MAX_TOTAL_SPEND_USD",
+          "description": "Lifetime cap in USD across all calls and restarts, tracked in a ledger at ~/.agent-press-wire/spend.json. Defaults to MAX_SPEND_USD (one paid call's worth).",
+          "isRequired": false,
+          "isSecret": false,
+          "format": "number"
+        },
+        {
+          "name": "AGENT_PRESS_WIRE_HOME",
+          "description": "Directory for the spend ledger (spend.json). Default ~/.agent-press-wire.",
+          "isRequired": false,
+          "isSecret": false,
+          "format": "string"
+        },
+        {
+          "name": "PRESS_API_URL",
+          "description": "Override the API base URL (testing only).",
+          "isRequired": false,
+          "isSecret": false,
+          "format": "string"
+        }
+      ]
+    }
+  ]
+}