domainagent-mcp 1.0.0

package/README.md

@@ -0,0 +1,174 @@
+# domainagent-mcp
+
+MCP server for [domainagent.dev](https://domainagent.dev) — the domain registrar built for AI agents.
+
+Search, register, deploy, and manage domains in one prompt. Pay with USDC on Base via x402.
+
+## What is domainagent?
+
+domainagent is an agent-first domain registrar. Instead of clicking through GoDaddy, your AI agent calls an API and gets:
+
+- **Domain search + registration** via Name.com
+- **Static site deployment** via Cloudflare Pages
+- **DNS management** (A, CNAME, MX, TXT records)
+- **SSL** (automatic via Cloudflare)
+- **Health checks** (DNS, HTTP, SSL, response time)
+- **Renewals** with expiry tracking
+- **Free transfer-out** with auth/EPP codes (no lock-in)
+- **x402 payment** — USDC on Base mainnet, no credit card needed
+
+## Install
+
+### npx (no install)
+```bash
+npx domainagent-mcp
+```
+
+### Claude Desktop / Cursor / MCP-compatible tools
+
+Add to your MCP config:
+
+```json
+{
+  "mcpServers": {
+    "domainagent": {
+      "command": "npx",
+      "args": ["domainagent-mcp"],
+      "env": {
+        "SHIPAGENT_API": "https://domainagent.dev"
+      }
+    }
+  }
+}
+```
+
+### Global install
+```bash
+npm install -g domainagent-mcp
+domainagent-mcp
+```
+
+## Tools
+
+| Tool | Description | Auth | Payment |
+|------|-------------|------|---------|
+| `domainagent_search` | Search available domains | — | Free |
+| `domainagent_recommend` | AI domain suggestions from a description | — | Free |
+| `domainagent_pricing` | TLD price list | — | Free |
+| `domainagent_status` | Check domain deployment status | — | Free |
+| `domainagent_health` | DNS + HTTP + SSL health check | — | Free |
+| `domainagent_renewals_due` | Domains expiring within 30 days | — | Free |
+| `domainagent_deploy` | Register + deploy + DNS + SSL | Wallet | x402 USDC |
+| `domainagent_redeploy` | Update existing deployment | Wallet | x402 USDC |
+| `domainagent_renew` | Renew domain registration | Wallet | x402 USDC |
+| `domainagent_auth_challenge` | Get wallet auth challenge | — | Free |
+| `domainagent_auth_verify` | Verify signed challenge → session token | — | Free |
+| `domainagent_list_domains` | List your domains | Token | Free |
+| `domainagent_dns_list` | List DNS records | Token | Free |
+| `domainagent_dns_add` | Add DNS record | Token | Free |
+| `domainagent_dns_delete` | Delete DNS record | Token | Free |
+| `domainagent_renewal_email` | Set renewal reminder email | Token | Free |
+| `domainagent_connect` | Connect your Cloudflare account | Token | Free |
+| `domainagent_transfer_out` | Get auth/EPP code for transfer | Token | Free |
+
+## Quick Start
+
+**Search for a domain:**
+```
+"Find me a domain for my fitness tracking app"
+→ domainagent_search({ query: "fitness tracker" })
+→ fittrack.dev — $14.99 (available)
+```
+
+**Deploy:**
+```
+"Deploy my app to fittrack.dev"
+→ domainagent_deploy({ domain: "fittrack.dev", owner: "0x...", filesBase64: "..." })
+→ 402 Payment Required: $16.99 USDC (domain + deploy fee)
+→ Agent signs USDC authorization, retries
+→ ✓ fittrack.dev is live with SSL
+```
+
+**Check health:**
+```
+"Is fittrack.dev working?"
+→ domainagent_health({ domain: "fittrack.dev" })
+→ DNS: ✓ | HTTP: 200 | SSL: valid | Response: 45ms
+```
+
+## Authentication
+
+Free tools (search, pricing, health) require no auth.
+
+Sensitive operations use wallet-based authentication:
+1. Call `domainagent_auth_challenge` with your wallet address
+2. Sign the returned message with your wallet
+3. Call `domainagent_auth_verify` with the signature
+4. Use the returned session token as `authToken` in subsequent calls
+
+Paid operations (deploy, redeploy, renew) use x402 — sign a USDC authorization on Base mainnet.
+
+## x402 Payment Flow
+
+Paid endpoints return `402 Payment Required` with details:
+- Network: Base mainnet (eip155:8453)
+- Token: USDC (`0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913`)
+- Amount: varies by operation
+
+Your agent signs a USDC authorization and retries with the `X-Payment` header. The [x402 protocol](https://www.x402.org/) handles the rest.
+
+## No Lock-in
+
+- **Free transfer-out** — get your auth/EPP code anytime via `domainagent_transfer_out`
+- **You own your domain** — registered in your name via Name.com (ICANN-accredited)
+- **Connect your own Cloudflare** — deploy to your infrastructure, not ours
+- **Open MCP** — this repo is MIT licensed
+
+## x402 Payment Signing
+
+Some MCP tools (deploy, redeploy, renew) require x402 USDC payment on Base mainnet.
+
+The `examples/` directory includes tools to make this easy:
+
+### x402-signer.js
+
+Signs x402 payment headers from your wallet. Use it when an MCP tool returns a 402:
+
+```bash
+# Install dependencies
+npm install viem @x402/core @x402/evm
+
+# Sign a payment from a saved 402 response
+node examples/x402-signer.js --payment-file payment-402.json --key 0xYOUR_KEY
+
+# Or pipe it
+echo '{"paymentDetails":{...}}' | node examples/x402-signer.js --key 0xYOUR_KEY
+
+# Use with env var
+export WALLET_PRIVATE_KEY=0x...
+node examples/x402-signer.js --payment-file payment-402.json
+```
+
+Output: a base64-encoded `PAYMENT-SIGNATURE` value ready to pass as `paymentSignature` in any MCP tool.
+
+### Full deploy flow example
+
+```bash
+export WALLET_PRIVATE_KEY=0x...
+export WALLET_ADDRESS=0x...
+export CONTACT_EMAIL=you@example.com
+
+./examples/agent-deploy-flow.sh mydomain.xyz ./my-site.zip
+```
+
+This script handles the complete flow: search → deploy attempt → sign payment → retry with signature → verify status.
+
+## API
+
+Full OpenAPI spec: [domainagent.dev/openapi.yaml](https://domainagent.dev/openapi.yaml)
+
+Agent discovery: [domainagent.dev/.well-known/agent.json](https://domainagent.dev/.well-known/agent.json)
+
+## License
+
+MIT

package/mcp-server.js

@@ -0,0 +1,1147 @@
+#!/usr/bin/env node
+/**
+ * ShipAgent MCP Server
+ * Exposes ShipAgent domain registration and deployment as MCP tools.
+ *
+ * Usage: node mcp-server.js
+ * Config: set SHIPAGENT_API env var to override API base URL (default: http://127.0.0.1:3001)
+ */
+
+"use strict";
+
+const { Server } = require("@modelcontextprotocol/sdk/server/index.js");
+const { StdioServerTransport } = require("@modelcontextprotocol/sdk/server/stdio.js");
+const {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} = require("@modelcontextprotocol/sdk/types.js");
+const https = require("https");
+const http = require("http");
+const { URL } = require("url");
+
+const API_BASE = (process.env.SHIPAGENT_API || "http://127.0.0.1:3001").replace(/\/$/, "");
+
+// --- HTTP helper ---
+
+function apiRequest(method, path, body, headers) {
+  return new Promise((resolve, reject) => {
+    const url = new URL(API_BASE + path);
+    const isHttps = url.protocol === "https:";
+    const transport = isHttps ? https : http;
+
+    const payload = body ? JSON.stringify(body) : null;
+    const options = {
+      hostname: url.hostname,
+      port: url.port || (isHttps ? 443 : 80),
+      path: url.pathname + url.search,
+      method,
+      headers: {
+        "Content-Type": "application/json",
+        "Accept": "application/json",
+        ...(payload ? { "Content-Length": Buffer.byteLength(payload) } : {}),
+        ...(headers || {}),
+      },
+    };
+
+    const req = transport.request(options, (res) => {
+      let data = "";
+      res.on("data", (chunk) => (data += chunk));
+      res.on("end", () => {
+        try {
+          resolve({ status: res.statusCode, headers: res.headers, body: JSON.parse(data) });
+        } catch {
+          resolve({ status: res.statusCode, headers: res.headers, body: data });
+        }
+      });
+    });
+
+    req.on("error", reject);
+    if (payload) req.write(payload);
+    req.end();
+  });
+}
+
+function formatResult(response) {
+  const { status, body } = response;
+
+  if (status === 402) {
+    // x402 payment required — give the agent everything it needs
+    const paymentInfo = response.headers["x-payment-required"] || response.headers["payment-required"];
+    let paymentDetails = {};
+    if (paymentInfo) {
+      try {
+        paymentDetails = JSON.parse(Buffer.from(paymentInfo, "base64").toString());
+      } catch {
+        paymentDetails = { raw: paymentInfo };
+      }
+    }
+    return {
+      isError: false,
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          paymentRequired: true,
+          statusCode: 402,
+          message: "x402 payment required. Sign a USDC authorization and retry with X-Payment header.",
+          paymentDetails,
+          bodyDetails: body,
+        }, null, 2),
+      }],
+    };
+  }
+
+  if (status >= 400) {
+    const msg = (typeof body === "object" && body.error) ? body.error : JSON.stringify(body);
+    return { isError: true, content: [{ type: "text", text: `Error ${status}: ${msg}` }] };
+  }
+
+  return { content: [{ type: "text", text: JSON.stringify(body, null, 2) }] };
+}
+
+// --- Tool definitions ---
+
+const TOOLS = [
+  {
+    name: "domainagent_auth_challenge",
+    description:
+      "Get a challenge message to sign with your wallet. First step of authentication. Returns a message containing a nonce that must be signed.",
+    inputSchema: {
+      type: "object",
+      required: ["owner"],
+      properties: {
+        owner: { type: "string", description: "Wallet address (0x...)" },
+      },
+    },
+  },
+  {
+    name: "domainagent_auth_verify",
+    description:
+      "Verify a signed challenge and get a session token. Second step of authentication. Use the token as Bearer auth for subsequent calls.",
+    inputSchema: {
+      type: "object",
+      required: ["owner", "signature", "message"],
+      properties: {
+        owner: { type: "string", description: "Wallet address" },
+        signature: { type: "string", description: "Signature of the challenge message" },
+        message: { type: "string", description: "The exact challenge message that was signed" },
+      },
+    },
+  },
+  {
+    name: "domainagent_list_domains",
+    description:
+      "List all domains owned by the authenticated wallet. Requires auth token.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        authToken: { type: "string", description: "Session token from auth/verify" },
+      },
+      required: ["authToken"],
+    },
+  },
+  {
+    name: "domainagent_health",
+    description:
+      "Check if a deployed domain is healthy — DNS resolution, HTTP status, SSL, response time. Free, no auth required.",
+    inputSchema: {
+      type: "object",
+      required: ["domain"],
+      properties: {
+        domain: { type: "string", description: "Domain to health-check (e.g. fittrack.dev)" },
+      },
+    },
+  },
+  {
+    name: "domainagent_dns_list",
+    description:
+      "List DNS records for a domain. Requires auth.",
+    inputSchema: {
+      type: "object",
+      required: ["domain", "authToken"],
+      properties: {
+        domain: { type: "string", description: "Domain name" },
+        authToken: { type: "string", description: "Session token" },
+      },
+    },
+  },
+  {
+    name: "domainagent_dns_add",
+    description:
+      "Add a DNS record (MX, TXT, CNAME, A, etc.) to a domain. Requires auth.",
+    inputSchema: {
+      type: "object",
+      required: ["domain", "type", "answer", "authToken"],
+      properties: {
+        domain: { type: "string", description: "Domain name" },
+        host: { type: "string", description: "Subdomain or empty for apex" },
+        type: { type: "string", description: "Record type (A, CNAME, MX, TXT, etc.)" },
+        answer: { type: "string", description: "Record value" },
+        ttl: { type: "number", description: "TTL in seconds (default 300)" },
+        authToken: { type: "string", description: "Session token" },
+      },
+    },
+  },
+  {
+    name: "domainagent_dns_delete",
+    description:
+      "Delete a DNS record by ID. Get record IDs from domainagent_dns_list. Requires auth.",
+    inputSchema: {
+      type: "object",
+      required: ["domain", "recordId", "authToken"],
+      properties: {
+        domain: { type: "string", description: "Domain name" },
+        recordId: { type: "string", description: "DNS record ID to delete" },
+        authToken: { type: "string", description: "Session token" },
+      },
+    },
+  },
+  {
+    name: "domainagent_renewal_email",
+    description:
+      "Set a renewal reminder email address for a domain. We'll email 30 days before expiry. Requires auth.",
+    inputSchema: {
+      type: "object",
+      required: ["domain", "email", "authToken"],
+      properties: {
+        domain: { type: "string", description: "Domain name" },
+        email: { type: "string", description: "Email address for renewal reminders" },
+        authToken: { type: "string", description: "Session token" },
+      },
+    },
+  },
+  {
+    name: "domainagent_connect",
+    description:
+      "Connect a Cloudflare account so deployments go to the customer's own infrastructure. One-time setup. Requires a Cloudflare API token with Pages:Edit and DNS:Edit permissions. Requires auth.",
+    inputSchema: {
+      type: "object",
+      required: ["cf_api_token", "authToken"],
+      properties: {
+        cf_api_token: { type: "string", description: "Cloudflare API token with Pages:Edit and DNS:Edit permissions" },
+        authToken: { type: "string", description: "Session token" },
+      },
+    },
+  },
+  {
+    name: "domainagent_transfer_out",
+    description:
+      "Get an auth/EPP code to transfer a domain to another registrar. Free — no charge. The domain will be unlocked and the auth code returned. Requires auth.",
+    inputSchema: {
+      type: "object",
+      required: ["domain", "authToken"],
+      properties: {
+        domain: { type: "string", description: "Domain to transfer out (e.g. fittrack.dev)" },
+        authToken: { type: "string", description: "Session token" },
+      },
+    },
+  },
+  {
+    name: "domainagent_renewals_due",
+    description:
+      "Check which domains are expiring within 30 days. Free. Optionally filter by owner wallet.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        owner: { type: "string", description: "Filter by wallet address (optional)" },
+      },
+    },
+  },
+  {
+    name: "domainagent_renew",
+    description:
+      "Renew a domain registration. Protected by x402 — costs domain renewal price + $2 fee in USDC.",
+    inputSchema: {
+      type: "object",
+      required: ["domain", "owner"],
+      properties: {
+        domain: { type: "string", description: "Domain to renew" },
+        owner: { type: "string", description: "Wallet address of the domain owner" },
+        paymentSignature: { type: "string", description: "x402 payment signature (after receiving payment details)" },
+      },
+    },
+  },
+  {
+    name: "domainagent_search",
+    description:
+      "Search for available domain names matching a keyword or phrase. Returns domain availability and pricing. Use this before deploying to find a good domain.",
+    inputSchema: {
+      type: "object",
+      required: ["query"],
+      properties: {
+        query: {
+          type: "string",
+          description: "Keyword or phrase to search for (e.g. 'fitness app', 'fittrack')",
+        },
+        tlds: {
+          type: "array",
+          description: "TLDs to search. Default: .com, .dev, .io, .app, .net, .xyz, .co",
+          items: { type: "string" },
+          example: [".com", ".dev"],
+        },
+      },
+    },
+  },
+  {
+    name: "domainagent_recommend",
+    description:
+      "Get AI-powered domain suggestions based on a natural language description of your project. Extracts keywords and searches for the best available options within your budget.",
+    inputSchema: {
+      type: "object",
+      required: ["description"],
+      properties: {
+        description: {
+          type: "string",
+          description: "Natural language description of your project (e.g. 'a fitness tracking app for runners')",
+        },
+        budget: {
+          type: "number",
+          description: "Maximum domain price in USD (default: 100)",
+        },
+      },
+    },
+  },
+  {
+    name: "domainagent_pricing",
+    description:
+      "Get the current TLD price list and fee structure for deploying via ShipAgent. Returns domain registration costs by TLD, plus deploy and redeploy fees.",
+    inputSchema: {
+      type: "object",
+      properties: {},
+    },
+  },
+  {
+    name: "domainagent_status",
+    description:
+      "Check the registration, deployment, DNS, and SSL status of a domain deployed through ShipAgent.",
+    inputSchema: {
+      type: "object",
+      required: ["domain"],
+      properties: {
+        domain: {
+          type: "string",
+          description: "Domain to check status for (e.g. fittrack.dev)",
+        },
+      },
+    },
+  },
+  {
+    name: "domainagent_deploy",
+    description: `Register a domain and deploy your app.
+Protected by x402 — you pay $2 USDC on Base mainnet, domain cost is included.
+
+This tool uses a two-step flow:
+1. Call with domain + owner + filesBase64 (+ optionally paymentSignature)
+2. If payment needed: you receive payment details — sign USDC authorization and retry with paymentSignature
+3. On success: domain is registered and files are deployed automatically
+
+Alternatively, if you want to separate payment from upload:
+1. Call without filesBase64 to get an uploadToken after payment
+2. Then call domainagent_upload with the token and your zip file (valid 30 min)
+
+The tool handles:
+- Domain availability check
+- Domain registration via Name.com
+- Deployment to Fly.io (or Cloudflare Pages if connected)
+- DNS configuration
+- SSL (automatic)
+
+Supported runtimes (auto-detected from your zip contents):
+- Static sites (HTML/CSS/JS) → served via Caddy
+- Node.js (package.json detected) → node:20-alpine
+- Python (requirements.txt detected) → python:3.12-slim with gunicorn/uvicorn
+- Docker (Dockerfile detected) → custom build
+
+Hosting tiers:
+- Static: starter ($3/mo), growth ($8/mo), pro ($20/mo)
+- App: app_sm ($12/mo, 256MB), app_md ($25/mo, 512MB), app_lg ($50/mo, 1GB)
+
+For Python/Node apps, use app_sm or higher. Static sites work on any tier.
+
+⚠️ By default, apps auto-stop after ~5 min idle and cold-start on the next request (~2-5s delay).
+Set alwaysOn: true to keep your app running 24/7 with zero cold starts.
+Always-on is free on app tiers (app_sm/md/lg). Static tiers (starter/growth/pro) have a +$2/mo surcharge.`,
+    inputSchema: {
+      type: "object",
+      required: ["domain", "owner", "filesBase64", "email"],
+      properties: {
+        domain: {
+          type: "string",
+          description: "Domain to register and deploy to (e.g. fittrack.dev)",
+        },
+        owner: {
+          type: "string",
+          description: "Your wallet address (used for ownership verification on redeployment)",
+        },
+        filesBase64: {
+          type: "string",
+          description: "Base64-encoded zip file of your site (must include index.html at root for static, or package.json/requirements.txt for apps)",
+        },
+        contacts: {
+          type: "object",
+          description: "ICANN registrant contact info. If omitted, account defaults are used. Required fields: firstName, lastName, email, phone, address1, city, state, zip, country",
+          properties: {
+            firstName: { type: "string" },
+            lastName: { type: "string" },
+            email: { type: "string" },
+            phone: { type: "string", description: "E.164 format, e.g. +1.5551234567" },
+            address1: { type: "string" },
+            city: { type: "string" },
+            state: { type: "string" },
+            zip: { type: "string" },
+            country: { type: "string", description: "2-letter ISO country code, e.g. US" },
+          },
+        },
+        alwaysOn: {
+          type: "boolean",
+          description: "Keep app running 24/7 with no cold starts. Default false (app sleeps after ~5 min idle). Recommended true for production apps.",
+        },
+        paymentSignature: {
+          type: "string",
+          description: "x402 payment signature (X-Payment header value) from a signed USDC authorization. Required after receiving payment details.",
+        },
+      },
+    },
+  },
+  {
+    name: "domainagent_upload",
+    description: `Upload files to complete a domain deployment after paying via domainagent_deploy.
+
+Use this when:
+- domainagent_deploy returned an uploadToken (payment succeeded, files not yet uploaded)
+- You have a base64-encoded zip file to deploy
+
+The uploadToken is valid for 30 minutes.`,
+    inputSchema: {
+      type: "object",
+      required: ["uploadToken", "filesBase64"],
+      properties: {
+        uploadToken: { type: "string", description: "Token returned by domainagent_deploy after payment" },
+        filesBase64: { type: "string", description: "Base64-encoded zip file of your site" },
+      },
+    },
+  },
+  {
+    name: "domainagent_redeploy",
+    description: `Update an existing ShipAgent deployment with new files.
+The domain must already be registered via domainagent_deploy.
+Costs $2 USDC via x402 payment.
+
+Steps:
+1. Call this tool with your domain, owner address, and updated zip file
+2. Receive x402 payment details
+3. Sign USDC authorization and retry with payment signature`,
+    inputSchema: {
+      type: "object",
+      required: ["domain", "owner", "filesBase64"],
+      properties: {
+        domain: {
+          type: "string",
+          description: "Domain to redeploy (must already be deployed)",
+        },
+        owner: {
+          type: "string",
+          description: "Your wallet address (must match original deployer)",
+        },
+        filesBase64: {
+          type: "string",
+          description: "Base64-encoded zip file with updated static site",
+        },
+        paymentSignature: {
+          type: "string",
+          description: "x402 payment signature after receiving payment details",
+        },
+      },
+    },
+  },
+  {
+    name: "domainagent_hosting_status",
+    description:
+      "Check hosting status, tier, usage, and billing info for a deployed domain.",
+    inputSchema: {
+      type: "object",
+      required: ["domain"],
+      properties: {
+        domain: { type: "string", description: "Domain to check hosting for" },
+      },
+    },
+  },
+  {
+    name: "domainagent_hosting_pay",
+    description:
+      "Pay hosting fee for a domain. Protected by x402. Send tier (starter/growth/pro) and billing (monthly/annual). Also resumes paused sites.",
+    inputSchema: {
+      type: "object",
+      required: ["domain"],
+      properties: {
+        domain: { type: "string", description: "Domain to pay hosting for" },
+        tier: { type: "string", description: "Hosting tier: starter, growth, or pro (default: current tier)" },
+        billing: { type: "string", description: "Billing cycle: monthly or annual (default: monthly)" },
+        paymentSignature: { type: "string", description: "x402 payment signature" },
+      },
+    },
+  },
+  {
+    name: "domainagent_hosting_pay_overage",
+    description:
+      "Pay outstanding bandwidth overage for a domain. Protected by x402. Amount is calculated from actual usage. Also resumes paused sites.",
+    inputSchema: {
+      type: "object",
+      required: ["domain"],
+      properties: {
+        domain: { type: "string", description: "Domain with outstanding overage" },
+        paymentSignature: { type: "string", description: "x402 payment signature" },
+      },
+    },
+  },
+  {
+    name: "domainagent_hosting_upgrade",
+    description:
+      "Upgrade the hosting tier for a domain. Requires auth. Does not charge — use domainagent_hosting_pay to pay for the new tier.",
+    inputSchema: {
+      type: "object",
+      required: ["domain", "tier", "authToken"],
+      properties: {
+        domain: { type: "string", description: "Domain to upgrade" },
+        tier: { type: "string", description: "New tier: starter, growth, or pro" },
+        billing: { type: "string", description: "Billing cycle: monthly or annual" },
+        authToken: { type: "string", description: "Session token" },
+      },
+    },
+  },
+  {
+    name: "domainagent_env_list",
+    description:
+      "List environment variable names (values masked) for a deployed domain. Requires auth.",
+    inputSchema: {
+      type: "object",
+      required: ["domain", "authToken"],
+      properties: {
+        domain: { type: "string", description: "Domain to list env vars for" },
+        authToken: { type: "string", description: "Session token" },
+      },
+    },
+  },
+  {
+    name: "domainagent_env_set",
+    description:
+      "Set one or more environment variables for a deployed domain. Restarts the app automatically. Requires auth.",
+    inputSchema: {
+      type: "object",
+      required: ["domain", "vars", "authToken"],
+      properties: {
+        domain: { type: "string", description: "Domain to set env vars for" },
+        vars: { type: "object", description: "Key-value pairs to set, e.g. { DATABASE_URL: 'postgres://...' }" },
+        authToken: { type: "string", description: "Session token" },
+      },
+    },
+  },
+  {
+    name: "domainagent_env_delete",
+    description:
+      "Delete an environment variable by key from a deployed domain. Restarts the app automatically. Requires auth.",
+    inputSchema: {
+      type: "object",
+      required: ["domain", "key", "authToken"],
+      properties: {
+        domain: { type: "string", description: "Domain to delete env var from" },
+        key: { type: "string", description: "Environment variable key to delete" },
+        authToken: { type: "string", description: "Session token" },
+      },
+    },
+  },
+  {
+    name: "domainagent_logs",
+    description:
+      "Fetch recent logs for a deployed domain. Only available for Fly-hosted apps. Requires auth.",
+    inputSchema: {
+      type: "object",
+      required: ["domain", "authToken"],
+      properties: {
+        domain: { type: "string", description: "Domain to fetch logs for" },
+        lines: { type: "number", description: "Number of log lines to return (default: 100)" },
+        authToken: { type: "string", description: "Session token" },
+      },
+    },
+  },
+  {
+    name: "domainagent_deploy_preview",
+    description:
+      `Deploy files to a preview URL without a custom domain. Good for testing before going live. Protected by x402 — $2 fee.
+
+Supported runtimes (auto-detected from your zip contents):
+- Static sites (HTML/CSS/JS) → served via Caddy
+- Node.js (package.json detected) → node:20-alpine
+- Python (requirements.txt detected) → python:3.12-slim with gunicorn/uvicorn
+- Docker (Dockerfile detected) → custom build
+
+Hosting tiers:
+- Static: starter ($3/mo), growth ($8/mo), pro ($20/mo)
+- App: app_sm ($12/mo, 256MB), app_md ($25/mo, 512MB), app_lg ($50/mo, 1GB)
+
+For Python/Node apps, use app_sm or higher. Static sites work on any tier.`,
+    inputSchema: {
+      type: "object",
+      required: ["owner", "filesBase64"],
+      properties: {
+        owner: { type: "string", description: "Wallet address" },
+        domain: { type: "string", description: "Optional domain to associate the preview with" },
+        hostingTier: { type: "string", description: "Hosting tier (default: starter)" },
+        filesBase64: { type: "string", description: "Base64-encoded zip file of your site" },
+        paymentSignature: { type: "string", description: "x402 payment signature" },
+      },
+    },
+  },
+  {
+    name: "domainagent_deploy_promote",
+    description:
+      "Promote a preview deployment to production on a custom domain. Requires auth.",
+    inputSchema: {
+      type: "object",
+      required: ["domain", "previewId", "authToken"],
+      properties: {
+        domain: { type: "string", description: "Domain to promote the preview to" },
+        previewId: { type: "string", description: "Preview app ID from domainagent_deploy_preview" },
+        authToken: { type: "string", description: "Session token" },
+      },
+    },
+  },
+  {
+    name: "domainagent_rollback",
+    description:
+      "Roll back a domain to its previous deployment. Requires at least 2 deploys in history. Requires auth.",
+    inputSchema: {
+      type: "object",
+      required: ["domain", "authToken"],
+      properties: {
+        domain: { type: "string", description: "Domain to roll back" },
+        authToken: { type: "string", description: "Session token" },
+      },
+    },
+  },
+  {
+    name: "domainagent_deploy_resume",
+    description: "Resume a failed deploy. If a deploy crashed after domain registration but before the app went live, this re-deploys from the saved zip without re-purchasing the domain.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        domain: { type: "string", description: "Domain to resume deploy for" },
+        authToken: { type: "string", description: "Session token from auth/verify" },
+      },
+      required: ["domain", "authToken"],
+    },
+  },
+  {
+    name: "domainagent_deploy_from_git",
+    description:
+      `Deploy directly from a GitHub repo URL. Clones the repo, auto-detects runtime (Node.js, Python, Docker, static), builds, and deploys. Protected by x402 — $2 fee.
+
+Supported runtimes (auto-detected from your repo contents):
+- Static sites (HTML/CSS/JS) → served via Caddy
+- Node.js (package.json detected) → node:20-alpine
+- Python (requirements.txt detected) → python:3.12-slim with gunicorn/uvicorn
+- Docker (Dockerfile detected) → custom build
+
+Hosting tiers:
+- Static: starter ($3/mo), growth ($8/mo), pro ($20/mo)
+- App: app_sm ($12/mo, 256MB), app_md ($25/mo, 512MB), app_lg ($50/mo, 1GB)
+
+For Python/Node apps, use app_sm or higher. Static sites work on any tier.`,
+    inputSchema: {
+      type: "object",
+      required: ["domain", "repoUrl", "owner", "email"],
+      properties: {
+        domain: { type: "string", description: "Domain to deploy to" },
+        repoUrl: { type: "string", description: "Git repository URL (e.g. https://github.com/user/repo)" },
+        branch: { type: "string", description: "Branch to deploy (default: main)" },
+        owner: { type: "string", description: "Wallet address" },
+        email: { type: "string", description: "Contact email for hosting notices" },
+        hostingTier: { type: "string", description: "Hosting tier (default: starter)" },
+        hostingBilling: { type: "string", description: "Billing cycle: monthly or annual" },
+        paymentSignature: { type: "string", description: "x402 payment signature" },
+      },
+    },
+  },
+];
+
+// --- Multipart form builder (for file upload endpoints) ---
+
+function buildMultipartForm(fields, fileFieldName, fileBuffer, fileName) {
+  const boundary = `----ShipAgentBoundary${Date.now()}`;
+  const parts = [];
+
+  for (const [name, value] of Object.entries(fields)) {
+    if (value == null) continue;
+    parts.push(
+      `--${boundary}\r\nContent-Disposition: form-data; name="${name}"\r\n\r\n${value}\r\n`
+    );
+  }
+
+  if (fileBuffer) {
+    parts.push(
+      `--${boundary}\r\nContent-Disposition: form-data; name="${fileFieldName}"; filename="${fileName || "files.zip"}"\r\nContent-Type: application/zip\r\n\r\n`
+    );
+  }
+
+  const textPart = Buffer.from(parts.join(""));
+  const endPart = Buffer.from(`\r\n--${boundary}--\r\n`);
+
+  let body;
+  if (fileBuffer) {
+    body = Buffer.concat([textPart, fileBuffer, endPart]);
+  } else {
+    body = Buffer.concat([textPart, endPart]);
+  }
+
+  return { body, contentType: `multipart/form-data; boundary=${boundary}` };
+}
+
+function multipartRequest(method, path, fields, fileBuffer, extraHeaders) {
+  return new Promise((resolve, reject) => {
+    const url = new URL(API_BASE + path);
+    const isHttps = url.protocol === "https:";
+    const transport = isHttps ? https : http;
+
+    const { body, contentType } = buildMultipartForm(
+      fields,
+      "files",
+      fileBuffer,
+      "files.zip"
+    );
+
+    const options = {
+      hostname: url.hostname,
+      port: url.port || (isHttps ? 443 : 80),
+      path: url.pathname + url.search,
+      method,
+      headers: {
+        "Content-Type": contentType,
+        "Content-Length": body.length,
+        "Accept": "application/json",
+        ...(extraHeaders || {}),
+      },
+    };
+
+    const req = transport.request(options, (res) => {
+      let data = "";
+      res.on("data", (chunk) => (data += chunk));
+      res.on("end", () => {
+        try {
+          resolve({ status: res.statusCode, headers: res.headers, body: JSON.parse(data) });
+        } catch {
+          resolve({ status: res.statusCode, headers: res.headers, body: data });
+        }
+      });
+    });
+
+    req.on("error", reject);
+    req.write(body);
+    req.end();
+  });
+}
+
+// --- Tool handlers ---
+
+async function handleTool(name, args) {
+  switch (name) {
+    case "domainagent_auth_challenge": {
+      const res = await apiRequest("POST", "/api/auth/challenge", { owner: args.owner });
+      return formatResult(res);
+    }
+
+    case "domainagent_auth_verify": {
+      const res = await apiRequest("POST", "/api/auth/verify", {
+        owner: args.owner,
+        signature: args.signature,
+        message: args.message,
+      });
+      return formatResult(res);
+    }
+
+    case "domainagent_list_domains": {
+      const res = await apiRequest("GET", "/api/domains", null, {
+        Authorization: `Bearer ${args.authToken}`,
+      });
+      return formatResult(res);
+    }
+
+    case "domainagent_health": {
+      const res = await apiRequest("GET", `/api/health/${encodeURIComponent(args.domain)}`);
+      return formatResult(res);
+    }
+
+    case "domainagent_dns_list": {
+      const res = await apiRequest("GET", `/api/dns/${encodeURIComponent(args.domain)}`, null, {
+        Authorization: `Bearer ${args.authToken}`,
+      });
+      return formatResult(res);
+    }
+
+    case "domainagent_dns_add": {
+      const res = await apiRequest("POST", `/api/dns/${encodeURIComponent(args.domain)}`, {
+        host: args.host || "",
+        type: args.type,
+        answer: args.answer,
+        ttl: args.ttl || 300,
+      }, { Authorization: `Bearer ${args.authToken}` });
+      return formatResult(res);
+    }
+
+    case "domainagent_dns_delete": {
+      const res = await apiRequest("DELETE", `/api/dns/${encodeURIComponent(args.domain)}/${args.recordId}`, null, {
+        Authorization: `Bearer ${args.authToken}`,
+      });
+      return formatResult(res);
+    }
+
+    case "domainagent_renewal_email": {
+      const res = await apiRequest("POST", "/api/renewal-email", {
+        domain: args.domain,
+        email: args.email,
+      }, { Authorization: `Bearer ${args.authToken}` });
+      return formatResult(res);
+    }
+
+    case "domainagent_connect": {
+      const res = await apiRequest("POST", "/api/connect", {
+        cf_api_token: args.cf_api_token,
+      }, { Authorization: `Bearer ${args.authToken}` });
+      return formatResult(res);
+    }
+
+    case "domainagent_transfer_out": {
+      const res = await apiRequest("POST", "/api/transfer-out", {
+        domain: args.domain,
+      }, { Authorization: `Bearer ${args.authToken}` });
+      return formatResult(res);
+    }
+
+    case "domainagent_renewals_due": {
+      const ownerParam = args.owner ? `?owner=${encodeURIComponent(args.owner)}` : "";
+      const res = await apiRequest("GET", `/api/renewals-due${ownerParam}`);
+      return formatResult(res);
+    }
+
+    case "domainagent_renew": {
+      const extraHeaders = {};
+      if (args.paymentSignature) extraHeaders["X-Payment"] = args.paymentSignature;
+        extraHeaders["PAYMENT-SIGNATURE"] = args.paymentSignature;
+      const res = await apiRequest("POST", "/api/renew", {
+        domain: args.domain,
+        owner: args.owner,
+      }, extraHeaders);
+      return formatResult(res);
+    }
+
+    case "domainagent_search": {
+      const res = await apiRequest("POST", "/api/search", {
+        query: args.query,
+        tlds: args.tlds,
+      });
+      return formatResult(res);
+    }
+
+    case "domainagent_recommend": {
+      const res = await apiRequest("POST", "/api/recommend", {
+        description: args.description,
+        budget: args.budget,
+      });
+      return formatResult(res);
+    }
+
+    case "domainagent_pricing": {
+      const res = await apiRequest("GET", "/api/pricing");
+      return formatResult(res);
+    }
+
+    case "domainagent_status": {
+      const domain = encodeURIComponent(args.domain);
+      const res = await apiRequest("GET", `/api/status/${domain}`);
+      return formatResult(res);
+    }
+
+    case "domainagent_deploy": {
+      const { domain, owner, filesBase64, paymentSignature, email, hostingTier, hostingBilling, contacts, alwaysOn } = args;
+
+      // Two-step deploy flow:
+      // Step 1: POST /api/deploy/prepare (JSON + x402) — registers domain, returns upload token
+      // Step 2: POST /api/deploy/upload (multipart) — uploads files, completes deploy
+
+      let fileBuffer = null;
+      if (filesBase64) {
+        try {
+          fileBuffer = Buffer.from(filesBase64, "base64");
+        } catch (err) {
+          return { isError: true, content: [{ type: "text", text: `Invalid base64 for filesBase64: ${err.message}` }] };
+        }
+      }
+
+      const prepareBody = { domain, owner, renewalEmail: email, hostingTier, hostingBilling };
+      if (contacts) prepareBody.contacts = contacts;
+
+      const extraHeaders = {};
+      if (paymentSignature) {
+        extraHeaders["X-Payment"] = paymentSignature;
+        extraHeaders["x-payment"] = paymentSignature;
+      }
+
+      // Step 1: Pay + register domain
+      const prepareRes = await apiRequest("POST", "/api/deploy/prepare", prepareBody, extraHeaders);
+
+      // If 402, return payment details to the agent
+      if (prepareRes.status === 402) return formatResult(prepareRes);
+
+      // If error, return it
+      if (prepareRes.status >= 400) return formatResult(prepareRes);
+
+      const uploadToken = prepareRes.body?.uploadToken;
+      if (!uploadToken) {
+        return { isError: true, content: [{ type: "text", text: `Prepare succeeded but no uploadToken returned: ${JSON.stringify(prepareRes.body)}` }] };
+      }
+
+      // If no files provided, return the token so agent can upload separately
+      if (!fileBuffer) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({
+            success: true,
+            domain,
+            uploadToken,
+            message: "Domain registered and payment received. Now call domainagent_upload with this token and your zip file to complete deployment.",
+            expiresInMinutes: 30,
+          }, null, 2) }],
+        };
+      }
+
+      // Step 2: Upload files
+      const uploadRes = await multipartRequest(
+        "POST",
+        "/api/deploy/upload",
+        { uploadToken },
+        fileBuffer,
+        {}
+      );
+
+      return formatResult(uploadRes);
+    }
+
+    case "domainagent_upload": {
+      const { uploadToken, filesBase64 } = args;
+      let fileBuffer;
+      try {
+        fileBuffer = Buffer.from(filesBase64, "base64");
+      } catch (err) {
+        return { isError: true, content: [{ type: "text", text: `Invalid base64: ${err.message}` }] };
+      }
+      const res = await multipartRequest("POST", "/api/deploy/upload", { uploadToken }, fileBuffer, {});
+      return formatResult(res);
+    }
+
+    case "domainagent_redeploy": {
+      const { domain, owner, filesBase64, paymentSignature } = args;
+
+      let fileBuffer = null;
+      if (filesBase64) {
+        try {
+          fileBuffer = Buffer.from(filesBase64, "base64");
+        } catch (err) {
+          return {
+            isError: true,
+            content: [{ type: "text", text: `Invalid base64 for filesBase64: ${err.message}` }],
+          };
+        }
+      }
+
+      const extraHeaders = {};
+      if (paymentSignature) {
+        extraHeaders["X-Payment"] = paymentSignature;
+        extraHeaders["PAYMENT-SIGNATURE"] = paymentSignature;
+      }
+
+      const res = await multipartRequest(
+        "POST",
+        "/api/redeploy",
+        { domain, owner },
+        fileBuffer,
+        extraHeaders
+      );
+
+      return formatResult(res);
+    }
+
+    case "domainagent_hosting_status": {
+      const res = await apiRequest("GET", `/api/hosting/${encodeURIComponent(args.domain)}`);
+      return formatResult(res);
+    }
+
+    case "domainagent_hosting_pay": {
+      const extraHeaders = {};
+      if (args.paymentSignature) extraHeaders["X-Payment"] = args.paymentSignature;
+        extraHeaders["PAYMENT-SIGNATURE"] = args.paymentSignature;
+      const res = await apiRequest("POST", "/api/hosting/pay", {
+        domain: args.domain,
+        tier: args.tier,
+        billing: args.billing,
+      }, extraHeaders);
+      return formatResult(res);
+    }
+
+    case "domainagent_hosting_pay_overage": {
+      const extraHeaders = {};
+      if (args.paymentSignature) extraHeaders["X-Payment"] = args.paymentSignature;
+        extraHeaders["PAYMENT-SIGNATURE"] = args.paymentSignature;
+      const res = await apiRequest("POST", "/api/hosting/pay-overage", {
+        domain: args.domain,
+      }, extraHeaders);
+      return formatResult(res);
+    }
+
+    case "domainagent_hosting_upgrade": {
+      const res = await apiRequest("POST", `/api/hosting/${encodeURIComponent(args.domain)}/upgrade`, {
+        tier: args.tier,
+        billing: args.billing,
+      }, { Authorization: `Bearer ${args.authToken}` });
+      return formatResult(res);
+    }
+
+    case "domainagent_env_list": {
+      const res = await apiRequest("GET", `/api/hosting/${encodeURIComponent(args.domain)}/env`, null, {
+        Authorization: `Bearer ${args.authToken}`,
+      });
+      return formatResult(res);
+    }
+
+    case "domainagent_env_set": {
+      const res = await apiRequest("POST", `/api/hosting/${encodeURIComponent(args.domain)}/env`, {
+        vars: args.vars,
+      }, { Authorization: `Bearer ${args.authToken}` });
+      return formatResult(res);
+    }
+
+    case "domainagent_env_delete": {
+      const res = await apiRequest("DELETE", `/api/hosting/${encodeURIComponent(args.domain)}/env/${encodeURIComponent(args.key)}`, null, {
+        Authorization: `Bearer ${args.authToken}`,
+      });
+      return formatResult(res);
+    }
+
+    case "domainagent_logs": {
+      const linesParam = args.lines ? `?lines=${args.lines}` : "";
+      const res = await apiRequest("GET", `/api/hosting/${encodeURIComponent(args.domain)}/logs${linesParam}`, null, {
+        Authorization: `Bearer ${args.authToken}`,
+      });
+      return formatResult(res);
+    }
+
+    case "domainagent_deploy_preview": {
+      const { owner, domain, hostingTier, filesBase64, paymentSignature } = args;
+
+      let fileBuffer = null;
+      if (filesBase64) {
+        try {
+          fileBuffer = Buffer.from(filesBase64, "base64");
+        } catch (err) {
+          return {
+            isError: true,
+            content: [{ type: "text", text: `Invalid base64 for filesBase64: ${err.message}` }],
+          };
+        }
+      }
+
+      const extraHeaders = {};
+      if (paymentSignature) extraHeaders["X-Payment"] = paymentSignature;
+        extraHeaders["PAYMENT-SIGNATURE"] = paymentSignature;
+
+      const fields = { owner };
+      if (domain) fields.domain = domain;
+      if (hostingTier) fields.hostingTier = hostingTier;
+
+      const res = await multipartRequest(
+        "POST",
+        "/api/deploy/preview",
+        fields,
+        fileBuffer,
+        extraHeaders
+      );
+
+      return formatResult(res);
+    }
+
+    case "domainagent_deploy_promote": {
+      const res = await apiRequest("POST", "/api/deploy/promote", {
+        domain: args.domain,
+        previewId: args.previewId,
+      }, { Authorization: `Bearer ${args.authToken}` });
+      return formatResult(res);
+    }
+
+    case "domainagent_rollback": {
+      const res = await apiRequest("POST", `/api/hosting/${encodeURIComponent(args.domain)}/rollback`, null, {
+        Authorization: `Bearer ${args.authToken}`,
+      });
+      return formatResult(res);
+    }
+
+    case "domainagent_deploy_resume": {
+      const res = await apiRequest("POST", "/api/deploy/resume", {
+        domain: args.domain,
+      }, { Authorization: `Bearer ${args.authToken}` });
+      return formatResult(res);
+    }
+
+    case "domainagent_deploy_from_git": {
+      const extraHeaders = {};
+      if (args.paymentSignature) extraHeaders["X-Payment"] = args.paymentSignature;
+        extraHeaders["PAYMENT-SIGNATURE"] = args.paymentSignature;
+      const res = await apiRequest("POST", "/api/deploy/from-git", {
+        domain: args.domain,
+        repoUrl: args.repoUrl,
+        branch: args.branch,
+        owner: args.owner,
+        email: args.email,
+        hostingTier: args.hostingTier,
+        hostingBilling: args.hostingBilling,
+      }, extraHeaders);
+      return formatResult(res);
+    }
+
+    default:
+      return {
+        isError: true,
+        content: [{ type: "text", text: `Unknown tool: ${name}` }],
+      };
+  }
+}
+
+// --- MCP server setup ---
+
+async function main() {
+  const server = new Server(
+    { name: "domainagent", version: "1.0.0" },
+    { capabilities: { tools: {} } }
+  );
+
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: TOOLS,
+  }));
+
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+      return await handleTool(name, args || {});
+    } catch (err) {
+      return {
+        isError: true,
+        content: [{ type: "text", text: `Tool error: ${err.message}` }],
+      };
+    }
+  });
+
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+
+  process.stderr.write(`domainagent MCP server running (API: ${API_BASE})\n`);
+}
+
+main().catch((err) => {
+  process.stderr.write(`Fatal: ${err.message}\n`);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "domainagent-mcp",
+  "version": "1.0.0",
+  "description": "MCP server for domainagent.dev — register domains, deploy apps, and manage DNS with x402 payments",
+  "main": "mcp-server.js",
+  "bin": {
+    "domainagent-mcp": "./mcp-server.js"
+  },
+  "scripts": {
+    "start": "node server.js"
+  },
+  "keywords": [
+    "mcp",
+    "domain",
+    "dns",
+    "deploy",
+    "x402",
+    "ai-agent",
+    "model-context-protocol"
+  ],
+  "author": "domainagent.dev",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mswat/domainagent-mcp"
+  },
+  "homepage": "https://domainagent.dev",
+  "type": "commonjs",
+  "engines": {
+    "node": ">=20.0.0 <23.0.0"
+  },
+  "overrides": {
+    "jose": "5.10.0"
+  },
+  "dependencies": {
+    "@coinbase/cdp-sdk": "^1.46.1",
+    "@coinbase/x402": "^2.1.0",
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "@supabase/supabase-js": "^2.101.1",
+    "@x402/core": "^2.9.0",
+    "@x402/evm": "^2.9.0",
+    "@x402/express": "^2.9.0",
+    "adm-zip": "^0.5.17",
+    "bs58": "^6.0.0",
+    "cors": "^2.8.6",
+    "dotenv": "^17.4.1",
+    "ethers": "^6.16.0",
+    "express": "^5.2.1",
+    "jose": "5.10.0",
+    "multer": "^2.1.1",
+    "siwe": "^3.0.0"
+  }
+}